玩转 TypeScript 工具类型（中）

type Exclude<T, U> = T extends U ? never : T;

// 排除一个具体的值
type T0 = Exclude<"a" | "b" | "c", "a">  // "b" | "c"
// 排除一种类型
type T1 = Exclude<string | number | (() => void), Function>

type T0 = Exclude<"a" | "b" | "c", "a">  // "b" | "c"
// 等价于
type T0 = "a" extends "a" ? never : "a" 
  | "b" extends "a" ? never : "b"
  | "c" extends "a" ? never : "c"
// 等价于
type T0 = never | "b" | "c"
// 等价于
type T0 = "b" | "c"

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

// 提取一个具体的值
type T0 = Extract<"a" | "b" | "c", "a">  // "b" | "c"
// 提取一种类型
type T1 = Extract<string | number | (() => void), Function>

type NonNullable<T> = T extends null | undefined ? never : T

type T0 = NonNullable<string | number | undefined>;
//  type T0 = string | number
type T1 = NonNullable<string[] | null | undefined>;
//  type T1 = string[]

let x: [string, number];

// OK
console.log(x[0].substring(1));
// Property 'substring' does not exist on type 'number'.
console.log(x[1].substring(1));

let x: [string, number];
x = ["hello", 10]; // OK
// Type '"world"' is not assignable to type 'undefined'.
// Tuple type '[string, number]' of length '2' has no element at index '3'.
x[3] = "world";
// Object is possibly 'undefined'.
// Tuple type '[string, number]' of length '2' has no element at index '5'.
console.log(x[5].toString());

/**
 * 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;

declare function f1(arg: { a: number; b: string }): void;
type T0 = Parameters<() => string>;
//  type T0 = []
type T1 = Parameters<(s: string) => void>;
//  type T1 = [s: string]
type T2 = Parameters<<T>(arg: T) => T>;
//  type T2 = [arg: unknown]
type T3 = Parameters<typeof f1>;
//  type T3 = [arg: { a: number; b: string; }]
type T4 = Parameters<any>;
//  type T4 = unknown[]
type T5 = Parameters<never>;
//  type T5 = never
type T6 = Parameters<string>;
//  Type 'string' does not satisfy the constraint '(...args: any) => any'.
type T7 = Parameters<Function>;
//  Type 'Function' does not satisfy the constraint '(...args: any) => any'.
//     Type 'Function' provides no match for the signature '(...args: any): any'.

/**
 * 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;

interface ErrorConstructor {
  new(message?: string): Error;
  (message?: string): Error;
  readonly prototype: Error;
}
type T0 = ConstructorParameters<ErrorConstructor>;

type T0 = string

/**
 * Obtain the return type of a function type
 */
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

declare function f1(): { a: number; b: string };
type T0 = ReturnType<() => string>;
//  type T0 = string
type T1 = ReturnType<(s: string) => void>;
//  type T1 = void
type T2 = ReturnType<<T>() => T>;
//  type T2 = unknown
type T3 = ReturnType<<T extends U, U extends number[]>() => T>;
//  type T3 = number[]
type T4 = ReturnType<typeof f1>;
//  type T4 = {a: number;b: string;}
type T5 = ReturnType<any>;
//  type T5 = any
type T6 = ReturnType<never>;
//  type T6 = never
type T7 = ReturnType<string>;
//  类型“string”不满足约束“(...args: any) => any”。ts(2344)
type T8 = ReturnType<Function>;
//  类型“Function”不满足约束“(...args: any) => any”。
//   类型“Function”提供的内容与签名“(...args: any): any”不匹配。ts(2344)

/**
 * 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 FunctionConstructor {
  /**
   * Creates a new function.
   * @param args A list of arguments the function accepts.
   */
  new(...args: string[]): Function;
  (...args: string[]): Function;
  readonly prototype: Function;
}
type T0 = InstanceType<FunctionConstructor>;

type T0 = Function;