interface Parent {
  id: string;
}
// 符合里氏替換原則，不會(huì)報(bào)錯(cuò)
interface Child extends Parent {
  id: "childIdA"|"childIdB"; // "childIdA"|"childIdB"是string的子集
  key: number; // Parent中沒(méi)有key，該屬性是Parent的拓展
}
// 不符合里氏替換原則，報(bào)錯(cuò)
interface ChildError extends Parent {
  id: number; // number不是string的子集
}
type A = {a: string};
type B = {a: "A"|"a", b: number};
let a: A = {a: "xxx"};
let b: B = {a: "a", b: 2};
// 符合B是A的子集，該賦值符合里氏替換原則, 反之 b=a 會(huì)報(bào)錯(cuò)
a = b;

type Fn<T> = T; // 看作 const Fn = val => val;

type R = "A" | "B"
type T = {
  [k in R]: k
}

type MyPick<T, K extends keyof T> = {
  [k in K]: T[k]
}
type A = MyPick<{a: string, b: number, c: boolean}, "a"|"c">

type Equal5<T> = T extends 5 ? true : false;

// eq1: 實(shí)現(xiàn)`GetProp<Obj, K>`（獲取Obj[K]類(lèi)型）
type GetProp<Obj, K> = K extends keyof Obj ? Obj[K] : undefined;
// eq2: 實(shí)現(xiàn)getName<User>
type GetName<User> = GetProp<User, "name">

// 實(shí)現(xiàn)KeyOf
type KeyOf<T> = T extends {[k in infer U]: unknown} ? U : never;
// 實(shí)現(xiàn)ValueOf
type ValueOf<T> = T extends { [k in keyof T]: infer U } ? U : never;
// 實(shí)現(xiàn)Parameters和ReturnType
type FuncBase<F, C extends "params"|"return"> = F extends (...params: infer P) => infer R ? (C extends "params" ? P : R) : never;
type Params<F> = FuncBase<F, "params">;
type Return<F> = FuncBase<F, "return">;

// 需要實(shí)現(xiàn)類(lèi)似js的const {name, ...extra} = user,求extra。（其實(shí)就是Omit方法）
type MyPick<Obj, T extends keyof Obj> = {[k in T]: Obj[k]};
type MyExclude<Obj, T extends keyof Obj> = keyof Obj extends T|(infer U extends keyof Obj) ? U : never;
type MyOmit<Obj, T extends keyof Obj> =  MyPick<Obj, MyExclude<Obj, T>>;
// 實(shí)現(xiàn)數(shù)組的解構(gòu)賦值const [A, ...extra] = arr;
type GetArrBase<T extends unknown[], C extends "first"|"rest"> = T extends [infer First, ...infer Rest] ? (C extends "first"?First: Rest): never;
type GetFirst<T extends unknown[]> = GetArrBase<T, "first">;
type GetRest<T extends unknown[]> = GetArrBase<T, "rest">;

type Obj = {
  name: string;
  age: 20;
}
Obj["name"] // string;
Obj.age // Error
Obj["age"] // 20
Obj['name'|'age'] // string | 20 , 這個(gè)特性很重要?。?！

interface Test {
  a: string;
  b: number;
  c: boolean;
}
// 之前不知道這個(gè)特性時(shí)，用infer也能達(dá)到同樣的效果，但實(shí)現(xiàn)不如這個(gè)直觀
type ValueOf<T> = T[keyof T];
type R = ValueOf<Test>;

type A = string[];
type B = [string, number, boolean];
// =========================分割線(xiàn)==========================
// 重點(diǎn)注意?。?！
A[0]; // string
A[1]; // string
B[0]; // string
B[1]; // number;
B[0|2]; // string|boolean
// 注意以下寫(xiě)法，為什么可以這么寫(xiě)，因?yàn)閚umber是所有數(shù)字的集合
A[number]; // string
B[number]; // string | number | boolean
A["length"]; // number
B["length"]; // 3
// ts數(shù)組同樣可以像js數(shù)組那樣展開(kāi)
type Spread<T extends unknown[]> = [...T]
Spread<[1,2,3]> // [1,2,3]

// eq1: 實(shí)現(xiàn) `ItemOf`方法（獲取數(shù)組中項(xiàng)的類(lèi)型）
type ItemOf<T extends unknown[]> = T[number];
// 之前不知道這個(gè)特性時(shí)，用infer實(shí)現(xiàn)的代碼如下
type ItemOfByinfer<T> = T extends (infer N)[] ? N : never;
// eq2:實(shí)現(xiàn)`Append`方法
type Append<T extends unknown[], Ele> = [...T, Ele];
// eq3: 實(shí)現(xiàn)返回?cái)?shù)組length+1
// ts雖然無(wú)法實(shí)現(xiàn)加減運(yùn)算，但可以通過(guò)模擬生成對(duì)應(yīng)新類(lèi)型，返回其屬性，從而模擬加減運(yùn)算
type LengthAddOne<T extends unknown[]> = [unknown, ...T]["length"];

// 返回Push后的數(shù)組
type Append<T extends unknown[], E = unknown> = [...T, U];
// 同理，返回Pop后的數(shù)組代碼如下，暫時(shí)用不到
// type RemoveTop<T extends unknown[]> = T extends [...(infer U), unknown] ? U : never;
type Tuple<N extends number, Arr extends unknown[] = []> = Arr["length"] extends N ? Arr : Tuple<N, Append<Arr>>

type Add<A extends number, B extends number> = [...Tuple<A>, ...Tuple<B>]["length"];
type Subtract<A extends number, B extends number> = Tuple<A> extends [...Tuple<B>, ...(infer U)] ? U["length"] : never;

type MultipleBase<A extends number, B extends number, S extends unknown[] = []> = 
    B extends 0
    ? S["length"]
    : MultipleBase<A, Subtract<B, 1>, [...S, ...Tuple<A>]>;

type BiggerThan<A extends number, B extends number> = Tuple<A> extends [...Tuple<B>, ...infer U] ? (U["length"] extends (never|0) ? false : true): false;
// 優(yōu)化后的乘法如下
type Mutiple<A extends number, B extends number> = BiggerThan<A, B> extends true ? MultipleBase<A, B> : MultipleBase<B, A>;

type Divide<A extends number, B extends number, R extends unknown[] = []> = BiggerThan<B, A> extends true ? R["length"] : Divide<Subtract<A,B>, B, Append<R>>;