TS进阶之条件类型

前端开发者对Javascript中的三元表达式应该都很熟悉，利用三元表达式可以很方便实现根据输入值得到不同的输出结果。 TypeScript对类型也提供了类似的语法，和Javascript唯一的区别就是TypeScript操作的是数据类型。

基本语法

基本使用

 T extends U ? X : Y;

• T U X Y 四个是占位符，分别表示四种类型；
• T extends U 表示 T类型能被赋值给U类型，这里还涉及到TS类型兼容性。

几个简单的例子

• 判断类型是否是string类型

type IsString = T extends string ? true : false;

type C11 = IsString; // true
type C22 = IsString;   // false

type C1 = IsString<"1">; // true
type C2 = IsString<1>;   // false

重点：例子中的true和 false是类型(字面量类型)，不是值。

• 如果是Animal类型得到number类型，否则为string类型

interface Animal {
  live(): void;
}
interface Dog extends Animal {
  woof(): void;
}

type IsAnimal = T extends Animal ? number : string;
type C3 = IsAnimal // number
type C4 = IsAnimal // string

TS进阶之keyof中的例子

• 实现Omit

type MyOmit = { [P in keyof T as P extends K ? never : P]: T[P] };

• 给对象类型添加属性

type AppendToObject = {[P in keyof T | U]: P extends keyof T ? T[P] : V}

条件类型可复合使用

例子如下：获取类型的名称

type TypeName = T extends string
  ? 'string'
  : T extends number
  ? 'number'
  : T extends boolean
  ? 'boolean'
  : T extends undefined
  ? 'undefined'
  : T extends Function
  ? 'function'
  : 'object';

这个使用方法应该也比较好理解，不过多解释了。

条件类型的分发特性

如果对条件类型的分发特性不太熟悉的同学可能会对Exclude,Extract等工具类型的实现有疑问，接下来我就使用Exclude来具体介绍下条件类型的分发特性。

重点：条件的分发特性主要针对的T是联合类型

Exclude的具体执行逻辑

type Exclude = T extends U ? never : T;
type C5 = Exclude<'a' | 'b' | 'c', 'a' | 'b'> // 'c'

解释：

1. 对联合类型T进行分发变成:

'a' extends 'a'| 'b' ? never : 'a' |
'b' extends 'a'| 'b' ? never : 'b' | 
'c' extends 'a'| 'b' ? never : 'c'

2. 分别计算的结果是 never ｜ never ｜ 'c'
3. 最后的结果: c

条件类型的分发必须是裸类型

裸类型是指没有被数组，元组和Promise等包装过的类型。

对比例子如下:

type IsString2 = [T] extends string[] ? "IS a String" : "Not a String";
type C7 = IsString2; 
// 结果: "Not a String"

type IsString3 = T extends string ? "IS a String" : "Not a String";
type C8 = IsString3; 
// 结果: "IS a String" | "Not a String"

1. IsString2中的[T]被数组包装过了，不会进行分发，直接判断[string | number] extends string[], 得到了"Not a String"；
2. IsString3中的[T]没被包装过，会进行分发,得到"IS a String" | "Not a String"；

never是空的联合类型

如果判断一个类型是否是never，可能最开始想到的是:

type IsNever = T extends never ? true : false; // ❌

这个是错误的，因为 never代表的是空的联合类型，相当于没有，所有不会执行，最后也是never类型，不会得到true。

正确的解决逻辑是将never变成元组类型就可以了。

type IsNever = [T] extends [never] ? true : false; // ✅

一些案例

获取数组类型的第一个元素的类型

type First = T extends never[] ? never : T[0];  

type arr1 = ['a', 'b', 'c']
type C6 = First // 'a'

注意 这里的'a','b','c'，是类型，是类型，是类型；

Pick 具有某个类型的属性

type PickByType = { [P in keyof T as T[P] extends U ? P : never]: T[P] };

type OnlyBoolean = PickByType<{
  name: string
  count: number
  isReadonly: boolean
  isEnable: boolean
}, boolean>

// 结果：
{
   isReadonly: boolean;
    isEnable: boolean;
}

判断Any

export type IsAny = 0 extends (1 & T) ? true : false

type IsAny = 0 extends (1 & T) ? true : false
type C9 = IsAny; // true
type C10 = IsAny; // false

解释: any & 1 = any, 0 extends any 成立，所以返回true; 具体解释地址

判断两个类型完全相等

export type Equal =
  (() => T extends X ? 1 : 2) extends
  (() => T extends Y ? 1 : 2) ? true : false
  

解释：通过构造一个函数类型来对比两个函数类型是否完全相等。具体解释地址

infer

条件类型语法中可以使用infer进行类型推断，下篇主要介绍这部分内容。

先来个官方的获取参数类型的例子:

type Parameters any> = T extends (...args: infer P) => any ? P : never;