const s = "hello";
let n = typeof s; // n 值是 "string",n 類型是 let n: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
let m: typeof s; // let m: stringconst s = "hello";
let n = typeof s; // n 值是 "string",n 類型是 let n: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
let m: typeof s; // let m: string

const point = { x:1,y:1 };
// 沒有指定類型，TS 默認(rèn)類型推理推導(dǎo)出合適類型
type PointType = typeof point;
/* 等價(jià)于
type PointType = {
    x: number;
    y: number;
}
*/
const person = { name: 'xxx'  } as any;
// as 強(qiáng)制類型轉(zhuǎn)換為 any， 使用強(qiáng)制類型轉(zhuǎn)化的類型作為結(jié)果
type PersonType = typeof person;
// 等價(jià)于 type PersonType = any
type Car = {
    drive: ()=>void;
    name?: string;
}
const car: Car = { drive:()=>{} }
// 使用了指定的類型作為修飾，結(jié)果返回類型為指定的類型
type CarType = typeof car;
/* 等價(jià)于
type CarType = {
    drive: () => void;
    name?: string | undefined;
}
*/const point = { x:1,y:1 };
// 沒有指定類型，TS 默認(rèn)類型推理推導(dǎo)出合適類型
type PointType = typeof point;
/* 等價(jià)于
type PointType = {
    x: number;
    y: number;
}
*/
const person = { name: 'xxx'  } as any;
// as 強(qiáng)制類型轉(zhuǎn)換為 any， 使用強(qiáng)制類型轉(zhuǎn)化的類型作為結(jié)果
type PersonType = typeof person;
// 等價(jià)于 type PersonType = any
type Car = {
    drive: ()=>void;
    name?: string;
}
const car: Car = { drive:()=>{} }
// 使用了指定的類型作為修飾，結(jié)果返回類型為指定的類型
type CarType = typeof car;
/* 等價(jià)于
type CarType = {
    drive: () => void;
    name?: string | undefined;
}
*/

const point = { x:1,y:1 };
type PointType = typeof point;
const person = { name: 'xxx'  } as any;
type PersonType = typeof person;
type PointKeysType = keyof PointType;
// 等價(jià)于 type PointKeysType = "x" | "y"
const point = { x:1,y:1 };
type PointType = typeof point;
const person = { name: 'xxx'  } as any;
type PersonType = typeof person;
type PointKeysType = keyof PointType;
// 等價(jià)于 type PointKeysType = "x" | "y"

type ToolsType = {
    [k:string]: Function
}
type ToolsKeys = keyof ToolsType; // string | number
// 將一個(gè)類型T上的所有屬性值作為新類型的 key 構(gòu)建新類型
type OptionsFlags<T> = {
    [k in keyof T]: boolean
}
type CarOpFlag = keyof OptionsFlags // 這里寫法不好，只做個(gè)演示。 等價(jià)于：type CarOpFlag = string | number | symbol
type ToolsType = {
    [k:string]: Function
}
type ToolsKeys = keyof ToolsType; // string | number
// 將一個(gè)類型T上的所有屬性值作為新類型的 key 構(gòu)建新類型
type OptionsFlags<T> = {
    [k in keyof T]: boolean
}
type CarOpFlag = keyof OptionsFlags // 這里寫法不好，只做個(gè)演示。 等價(jià)于：type CarOpFlag = string | number | symbol

interface User {
    name: string;
}
interface Student extends User {
    age: number;
}
const s:Student = {
    age: 11,
    name: 'xx'
};
interface User {
    name: string;
}
interface Student extends User {
    age: number;
}
const s:Student = {
    age: 11,
    name: 'xx'
};

interface User {
    name: string;
}
interface Student extends User {
    age: number;
}
function registeredStudent<T extends User>(user: T) {
    // ...
}
interface User {
    name: string;
}
interface Student extends User {
    age: number;
}
function registeredStudent<T extends User>(user: T) {
    // ...
}

type GetReturnType<T> = T extends (...args: any[]) => infer Return ? Return : never;
type HandleType = (msg: string) => number | string;
type returnType = GetReturnType<HandleType>
// 等價(jià)于 type returnType = string | numbertype GetReturnType<T> = T extends (...args: any[]) => infer Return ? Return : never;
type HandleType = (msg: string) => number | string;
type returnType = GetReturnType<HandleType>
// 等價(jià)于 type returnType = string | number

// TypeScript 官方提供的一些類型操作工具源碼
/**
 * Obtain the parameters of a function type in a tuple
 */
type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;
/**
 * Obtain the parameters of a constructor function type in a tuple
 */
type ConstructorParameters<T extends abstract new (...args: any) => any> = T extends abstract new (...args: infer P) => any ? P : never;
/**
 * Obtain the return type of a function type
 */
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
/**
 * Obtain the return type of a constructor function type
 */
type InstanceType<T extends abstract new (...args: any) => any> = T extends abstract new (...args: any) => infer R ? R : any;
// TypeScript 官方提供的一些類型操作工具源碼
/**
 * Obtain the parameters of a function type in a tuple
 */
type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;
/**
 * Obtain the parameters of a constructor function type in a tuple
 */
type ConstructorParameters<T extends abstract new (...args: any) => any> = T extends abstract new (...args: infer P) => any ? P : never;
/**
 * Obtain the return type of a function type
 */
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
/**
 * Obtain the return type of a constructor function type
 */
type InstanceType<T extends abstract new (...args: any) => any> = T extends abstract new (...args: any) => infer R ? R : any;

interface User {
    name: string;
}
type RequestUser = (id: number) => Promise<User>;
// 從返回值類型中提取到，Promise 里面的具體類型
type ResultType = Awaited<ReturnType<RequestUser>>interface User {
    name: string;
}
type RequestUser = (id: number) => Promise<User>;
// 從返回值類型中提取到，Promise 里面的具體類型
type ResultType = Awaited<ReturnType<RequestUser>>

/**
 * Recursively unwraps the "awaited type" of a type. Non-promise "thenables" should resolve to `never`. This emulates the behavior of `await`.
 */
type Awaited<T> =
    T extends null | undefined ? T : // special case for `null | undefined` when not in `--strictNullChecks` mode
        T extends object & { then(onfulfilled: infer F, ...args: infer _): any } ? // `await` only unwraps object types with a callable `then`. Non-object types are not unwrapped
            F extends ((value: infer V, ...args: infer _) => any) ? // if the argument to `then` is callable, extracts the first argument
                Awaited<V> : // recursively unwrap the value
                never : // the argument to `then` was not callable
        T; // non-object or non-thenable

type DataType = {
  id: number;
  origin?: string;
}
function mergeData(data: DataType, rest: Partial<DataType>): DataType {
  return { ...data, ...rest };
}
function save(data: Required<DataType>) {
    // 寫庫需要完整的數(shù)據(jù)， 包括 id 和 origin 來個(gè)字段
}
const data: DataType = { id: 11 };
// ?
const result = mergeData(data, {origin: 'DB-1'});
// ?
save(data);
/* Error
Argument of type 'DataType' is not assignable to parameter of type 'Required<DataType>'.
  Types of property 'origin' are incompatible.
    Type 'string | undefined' is not assignable to type 'string'.
      Type 'undefined' is not assignable to type 'string'
*/

// 源碼實(shí)現(xiàn)
/**
 * Make all properties in T optional
 */
type Partial<T> = {
    [P in keyof T]?: T[P];
};
/**
 * Make all properties in T required
 */
type Required<T> = {
    [P in keyof T]-?: T[P];
};
/**
 * Make all properties in T readonly
 */
type Readonly<T> = {
    readonly [P in keyof T]: T[P];
};

function dataTransfer(a: number, b: string, c: Array<number>): boolean {
    return false;
}
type dataTransferReturnType = ReturnType<typeof dataTransfer> 
// 值類型 type dataTransferReturnType = boolean
type dataTransferParametersType = Parameters<typeof dataTransfer> 
// 類型值 type dataTransferParametersType = [a: number, b: string, c: number[]]
interface User {
    name: string;
}
class Student {
    private name:string;
    private age:number;
    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }
}
type StudentConstructorParametersType = ConstructorParameters<typeof Student>
// 值類型： type StudentConstructorParametersType = [name: string, age: number]function dataTransfer(a: number, b: string, c: Array<number>): boolean {
    return false;
}
type dataTransferReturnType = ReturnType<typeof dataTransfer> 
// 值類型 type dataTransferReturnType = boolean
type dataTransferParametersType = Parameters<typeof dataTransfer> 
// 類型值 type dataTransferParametersType = [a: number, b: string, c: number[]]

// 源碼
type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;
/**
 * Obtain the parameters of a constructor function type in a tuple
 */
type ConstructorParameters<T extends abstract new (...args: any) => any> = T extends abstract new (...args: infer P) => any ? P : never;
/**
 * Obtain the return type of a function type
 */
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

interface Todo {
  title: string;
  description: string;
  completed: boolean;
}
type TodoPreview = Pick<Todo, "title" | "completed">;
const todo: TodoPreview = {
  title: "Clean room",
  completed: false,
};
//##__________________________________##
interface CatInfo {
  age: number;
  breed: string;
}
type CatName = "miffy" | "boris" | "mordred";
const cats: Record<CatName, CatInfo> = {
  miffy: { age: 10, breed: "Persian" },
  boris: { age: 5, breed: "Maine Coon" },
  mordred: { age: 16, breed: "British Shorthair" },
};

// 源碼
/**
 * From T, pick a set of properties whose keys are in the union K
 */
type Pick<T, K extends keyof T> = {
    [P in K]: T[P];
};
/**
 * Construct a type with a set of properties K of type T
 */
type Record<K extends keyof any, T> = {
    [P in K]: T;
};

type T0 = Exclude<"a" | "b" | "c", "a">;    
//type T0 = "b" | "c"
type T1 = Exclude<"a" | "b" | "c", "a" | "b">;   
//type T1 = "c"
type T2 = Exclude<string | number | (() => void), Function>;     
// type T2 = string | number
type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; x: number }
  | { kind: "triangle"; x: number; y: number };
type T3 = Exclude<Shape, { kind: "circle" }>
// type T3 =  | { kind: "square"; x: number } | { kind: "triangle"; x: number; y: number };

type T0 = Extract<"a" | "b" | "c", "a" | "f">;
//    ^?
// type T0 = "a";
type T1 = Extract<string | number | (() => void), Function>;
//    ^?
// T1 = ()=>void
type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; x: number }
  | { kind: "triangle"; x: number; y: number };
type T2 = Extract<Shape, { kind: "circle" }>
//    ^?
// type T2 = { kind: "circle"; radius: number }
type T0 = Extract<"a" | "b" | "c", "a" | "f">;
//    ^?
// type T0 = "a";
type T1 = Extract<string | number | (() => void), Function>;
//    ^?
// T1 = ()=>void
type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; x: number }
  | { kind: "triangle"; x: number; y: number };
type T2 = Extract<Shape, { kind: "circle" }>
//    ^?
// type T2 = { kind: "circle"; radius: number }

// 源碼
/**
 * Exclude from T those types that are assignable to U
 */
type Exclude<T, U> = T extends U ? never : T;
/**
 * Extract from T those types that are assignable to U
 */
type Extract<T, U> = T extends U ? T : never;

type Shape = 
  |{ kind: "circle"; radius: number, x:string }
  | { kind: "square"; x: number }
  | { kind: "triangle"; x: boolean; y: number };
// 自定義一個(gè)工具類型
type PickOneKeyType<T, K extends string> = K extends keyof T ? ({ [P in K]: T[P] })[K] : never
type XType = PickOneKeyType<Shape, 'x'>
// type XType = string | number | boolean
type KindType = PickOneKeyType<Shape, 'kind'>
// type kindType = "circle" | "square" | "triangle"

type PointType = {
  x: number;
  y: number;
  getCoords: ()=> [number, number]
}

type DataType = Omit<PointType, 'getCoords'>
/*
type DataType = {
    x: number;
    y: number;
}

// 源碼
/**
 * Construct a type with the properties of T except for those in type K.
 */
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;