TypeScript 类型体操练习（一）

实现 Pick

Pick工具类型通过从 Type 中选取一组属性 Keys（字符串字面或字符串字面的并集）来构造一个新的类型。

 interface Todo {
     title: string;
     description: string;
     completed: boolean;
 }
 type MyPick<T, K extends keyof T> = {
     [k in K]: T[k];
 };

 type P = MyPick<Todo,'title'|'completed'>

实现Readonly

将对象类型中的属性变为只读的

type MyReadonly<T> = {
    readonly [k in keyof T]: T[k];
};

元组转换成对象

 const tuple = ['tesla', 'model 3', 'model X', 'model Y'] as const;

 type TupleToObject<T extends ReadonlyArray<string | number>> = {
     [k in T[number]]: k
 };

 type result = TupleToObject<typeof tuple>;

数组索引访问将值的类型变成联合类型

First of Array

 type arr1 = ['a', 'b', 'c'];
 type arr2 = [3, 2, 1];

 type First<T extends any[]> = T extends [] ? never : T[0];
 //answer2
 type First<T extends any[]> = T['length'] extends 0 ? never : T[0]
 //answer3
 type First<T extends any[]> = T extends [infer A, ...infer rest] ? A : never

元组的长度

 type Length<T extends ReadonlyArray<any>> = T['length'];

 type teslaLength = Length<tesla> // expected 4
 type spaceXLength = Length<spaceX> // expected 5

实现内置的 Exclude<T, U> 类型

从联合类型 T 中排除 U 中的类型，来构造一个新的类型。

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

 type Result = MyExclude<'a' | 'b' | 'c', 'a'>;

Awaited 实现

假如我们有一个 Promise 对象，这个 Promise 对象会返回一个类型。在 TS 中，我们用 Promise 中的 T 来描述这个 Promise 返回的类型。

type MyAwaited<T extends Thenable<any> | Promise<any>> =
T extends Promise<infer Inner>
? Inner extends Promise<any>
   ? MyAwaited<Inner>
   : Inner
: T extends Thenable<infer U>
? U
: false;

type Result2 = MyAwaited<ExampleType>;

IF 实现

实现一个 IF 类型，它接收一个条件类型 C ，一个判断为真时的返回类型 T ，以及一个判断为假时的返回类型 F。 C 只能是 true 或者 false， T 和 F 可以是任意类型。

type If<C extends boolean, T, F> = C extends true ? T : F;

type A = If<true, 'a', 'b'>;

Concat 实现

在类型系统里实现 JavaScript 内置的 Array.concat 方法，这个类型接受两个参数，返回的新数组类型应该按照输入参数从左到右的顺序合并为一个新的数组。

type Concat<T extends any[], U extends any[]> = [...T,...U];

type Result = Concat<[1,5], [2]>;

Includes 实现

在类型系统里实现 JavaScript 的 Array.includes 方法，这个类型接受两个参数，返回的类型要么是 true 要么是 false。

// 方式1
type Includes<T extends any[], U> = U extends T[number] ? true : false;
type isPillarMen = Includes<['Kars', 'Esidisi', 'Wamuu', 'Santana'], 'kio'>; // expected to be `false

// 方式2
type Includes<T extends readonly any[], U> = { [P in T[number]]: true; }[U] extends true? true : false;

type isPillarMen = Includes<['Kars', 'Esidisi', 'Wamuu', 'Santana'], 'kio'>; // expected to be `false`

Push 的实现

在类型系统里实现通用的 Array.push。

type Push<T extends unknown[], U> = [...T, U];

type Result = Push<[1, 2], '3'>; // [1, 2, '3']

Unshift的实现

在类型系统里实现通用的 Array.unshift的实现

type Unshift<T extends unknown[], U> = [U, ...T];

type Result = Unshift<[1, 2], 0>; // [0, 1, 2,]

Parameters实现

从函数类型 Type 的参数中使用的类型构造元组类型。

const foo = (arg1: string, arg2: number): void => {};

type MyParameters<T> = T extends (...arg: infer P) => any ? P : never;

type FunctionParamsType = MyParameters<typeof foo>;