20.11.03

ts
Conditional types
常用于类型分发

 T extends U ? T : never

原理类似三目，意思就是 T 是否是 U 的子类型，是返回 ? 侧的 T，不是返回 : 侧的 never；

Typescript 本身是（Structural Type System 结构类型系统），意思大致就是只要两个类型定义的 形状结构（Shape）相同，类似鸭子类型的概念，这两个类型就相同。
https://www.typescriptlang.org/docs/handbook/interfaces.html

One of TypeScript’s core principles is that type checking focuses on the shape that values have. This is sometimes called “duck typing” or “structural subtyping”. In TypeScript, interfaces fill the role of naming these types, and are a powerful way of defining contracts within your code as well as contracts with code outside of your project.

Conditional types 就是利用这个特性，T 的结构能够与 U 重合（T 可分配给 U），那 T 就是 U 的子类型。

基本的使用就是取两个联合类型的 交集（Intersection） 或 差集：

/**
 * 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 A = 'a' | 'b' | 'c' | 'd';
type B = 'a' | 'c' | 'f';
type Intersection = Extract<A, B>; // A & B
type Union = A | B;
type Difference = Exclude<A, B>;

用于函数重载：
https://www.typescriptlang.org/docs/handbook/2/conditional-types.html
number，string或 number ｜ string 都可被分配给 number ｜ string，所以可以使用 Conditional types 进行 T 类型的校验，并分配到具体的子类型。

interface IdLabel {
  id: number /* some fields */;
}
interface NameLabel {
  name: string /* other fields */;
}
function createLabel(id: number): IdLabel;
function createLabel(name: string): NameLabel;
function createLabel(nameOrId: string | number): IdLabel | NameLabel;
function createLabel(nameOrId: string | number): IdLabel | NameLabel {
  // unimplemented;
}
// 可替换为
type NameOrId<T extends number | string> = T extends number
  ? IdLabel
  : NameLabel;
function createLabel<T extends number | string>(idOrName: T): NameOrId<T> {
  // unimplemented;
}
let a = createLabel("typescript");
//  ^ = let a: NameLabel
let b = createLabel(2.8);
//  ^ = let b: IdLabel
let c = createLabel(Math.random() ? "hello" : 42);
//  ^ = let c: NameLabel | IdLabel

同时 配合 infer 可以实现更多效果，如内置的：
infer 相当于在 类型分发 过程中的占位符。

/**
 * 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 new (...args: any) => any> = T extends 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;
// 实现一个取{ [key: string]: (a: unknow) => void } 结构体中所有 a 的交叉类型；
type ParamsIntersection<T> = T extends {
  [key: string]: (x: infer U) => void;
}
  ? U
  : never;
type Params = ParamsIntersection<{
  a: (a: string) => void;
  b: (b: { b: number }) => void;
}>; // string & { b: number; }

以及可能有点用的 UnionType -> IntersectionType:
https://stackoverflow.com/questions/50374908/transform-union-type-to-intersection-type
原理：
https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#type-inference-in-conditional-types
https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types

深度学习 Conditional Type：
https://zhuanlan.zhihu.com/p/54193438