面向类型编程：Typescript 中的高级类型

interface IPet {
  name: string;
}

interface IAnimal {
  favorites?: string[];
}
//  ICat 类型继承自 IPet 及 IAnimal，因此也拥有字符串类型的 name 属性, 以及 字符串数组类型的 favorites 属性
interface ICat extends IPet, IAnimal {
  color: string;
}

type NumberArray = Array<number>;
const numberList: NumberArray = [1, 3, 10, 20];

type CatArray = Array<ICat>;
const catList: CatArray = [
  // ...
];

//  value 既可以是 number，也可以是 string, 它的类型是 number 与 string 的并集
let value: number | string = 100;
value = '100';

interface IApple {
  name: string;
  color: string;
}
interface IBanana {
  name: string;
  length: number;
}
//  fruit 的类型是多个(复杂)类型的并集
let fruit: IApple | IBanana | undefined;

//  IAppleBanana 具有全部的三种属性 name, color, length，因此它既可以认为是 IApple，也可以认为是 IBanana, 是 IApple 与 IBanana 的交集。
type IAppleBanana = IApple & IBanana;
const ab: IAppleBanana = {
  name: 'ab',
  color: 'red',
  length: 10,
};

//  声明接口，满足该接口声明的对象必然具有 x, y 属性
interface IPoint {
  x: number;
  y: number;
  type: string;
}
//  使用关键字 keyof 获得 IPoint 的全部 key 组成的合集
//  相当于 type IKeyOfPoint = 'x' | 'y' | 'type';
type IKeyOfPoint = keyof IPoint;

//  既然有了“键”, 就可以通过 [] 运算符获取“值”：
//  相当于 IValueOfPoint = string | number;
type IValueOfPoint = IPoint[IKeyOfPoint];

//  从 IPoint 里取特定的键值
function getValueFromPoint(obj: IPoint, key: IKeyOfPoint): IValueOfPoint {
  return obj[key];
}

//  只使用一个泛型 T
function getValues<T>(obj: T, keys: Array<keyof T>) {
  return keys.map(key => obj[key]);
}
//  使用两个泛型 T, K，其中 K 必须要从类型 "keyof T" 继承而来, 并且输出类型与原类型一一对应
function plunk<T, K extends keyof T>(obj: T, keys: K[]): T[K][] {
  return keys.map(key => obj[key]);
}

const apple: IApple = {
  name: 'apple',
  color: 'red',
};
const appleValues = pluck(apple, ['name', 'color']);

// 将泛型 T 的所有键都标记为非必须(?)
type Partial<T> = {
  [P in keyof T]?: T[P];
}
// Partial<IPoint> 是 IPoint 的键值对非必需版本， 相当于 { x?: number; y?: number; type?: string }
const p0: Partial<IPoint> = {
  x: 200,
}

// 将泛型 T 的所有键都去除掉非必须(-?)
type Required<T> = {
  [P in keyof T]-?: T[P];
};
//  Required<Partial<IPoint>> 是 Partial<IPoint> 的键值对必需版本，相当于又回到了 IPoint
const p1: Required<Partial<IPoint>> = {
  x: 100,
  y: 100,
  type: 'rect',
}

//  从泛型 T 的所包含的键值类型中选择若干，并构成一个新的类型
type Pick<T, K extends keyof T> = {
  [P in K]: T[P];
}

//  Pick<IPoint, 'x' | 'y'> 从 IPoint 中选择 'x' 和 'y' 组成新的对象类型, 相当于 { x: number, y: number }
const p2: Pick<IPoint, 'x' | 'y'> = {
  x: 200,
  y: 200,
}

//  类型 FruitType<T> 实际类型由泛型推断而来
//  如果 T 满足 number 类型的约束，则返回 IApple 类型；否则返回 IBanana 类型
type FruitType<T> = T extends number ? IApple : IBanana;

//  f 被推断为 IApple 对象
const f:FruitType<123> = {
  name: 'apple',
  color: 'red',
}

//  定义两个 Union 类型
type ICollectionA = 100 | 'abc' | null;
type ICollectionB = undefined | null;

//  从泛型 T 中过滤选择出能够满足 泛型 U 约束的类型
//  注意这里和直观的认知不同，并不是真的返回完整的 T 类型，而是返回 T 类型中满足 U 约束的类型
type Filter<T, U> = T extends U ? T : never;

//  从 100 | 'abc' | null 中过滤出满足 undefined | null 的类型，即 null
type INull = Filter<ICollectionA, ICollectionB>;

//  与 Filter 刚好相反，从泛型 T 中剔除能够满足泛型 U 约束的类型
type Exclude<T, U> = T extends U ? never : T;

//  从 100 | 'abc' | null 中排除掉满足 undefined | null 的类型，即 100 | 'abc
type IDefined = Exclude<ICollectionA, ICollectionB>;

//  与 Pick<T, K> 正好相反，从 T 中去除 K 包含的类型
//  先把 T 对象中的所有键类型罗列出来，并从中移除满足 K 约束的，再利用 Pick 将剩余的键类型保留为新的对象类型
type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;

//  从 IPoint 中剥离键满足 'type' 的类型
const IXY: Omit<IPoint, 'type'> = {
  x: 100,
  y: 100,
}

//  对外暴露的类型，指示用户配置项的每一个属性都是可选的
export interface IOptions {
  uid?: number;
  name?: string;
}

//  对外暴露的方法
export function useModule(options?: IOptions) {
  const opt: Required<IOptions> = {
    uid: 0,
    name: 'none',
    ...options,
  }
  // 后续使用 opt 时，都可以认为每个属性都存在
  // ...
}