TypeScript高级类型

交叉类型

将多个类型合并成一个类型，取两个类型的并集。与继承的区别是，继承可以有自己的属性，而交叉没有。

interface DogInterface {
   run():void
}
interface CatInterface {
   jump():void
}
let pet: DogInterface & CatInterface = { // 看上去和接口多继承很像，但有一点区别。继承可以有自己的属性，交叉不行。
   run(){},
   jump(){},
};

联合类型

声明的类型并不确定，可以是多个类型中的一个。

let a: number | string = "a"; // 类型限定
let b: "a" | "b" | "c"; // 限定取值
let c: 1 | 2 | 3 | "v"; // 限定取值

可区分的类型保护：

// 现在有两种形状，area函数用来计算每种形状的面积。
interface Square{
   kind: "square";
   size: number;
}
interface Rectangle{
   kind: "rectangle",
   width: number,
   height: number,
}
type Shape = Square | Rectangle;
function area(s: Shape) {
   switch (s.kind) {
      case "square":
         return s.size * s.size; // 此区块内，确保只有size属性
      case "rectangle":
         return s.height * s.width;
   }
}
console.log(area({kind:"square",size:10})); // 100
// 现在要添加一个形状：圆形。需要定义接口Circle、为Shape添加联合类型Circle，然后为area函数内增加一个case。但是，如果我们忘了修改area函数，会发生什么？
interface Circle{
   kind: "circle",
   r: number,
}
type Shape = Square | Rectangle | Circle;
console.log(area({kind:"circle",r:10})); // undefined，这里并不报错，并不符合我们的预期。我们希望bug能够及时暴露出来，增加程序的稳定性。
做如下改动：
function area(s: Shape) {
   switch (s.kind) {
      case "square":
         return s.size * s.size;
      case "rectangle":
         return s.height * s.width;
      case "circle":
         return Math.PI * s.r;
      default:
         return ((e: any)=>{throw new Error(`没有定义 ${s} 的面积计算方式`)})(s) // 这一步很重要，一定要在这里抛出异常
   }
}

索引类型

当我们使用不存在的索引时，会返回undefined，没有约束（如下代码）。因此我们需要有对索引的约束。

let obj = {
   a: 1,
   b: 2,
   c: 3,
};
function getValue(obj: any,keys: string[]){
   return keys.map(key => obj[key]);
}
console.log(getValue(obj,["a","b"]));
console.log(getValue(obj,["c","f"])); // 会发现，'f'对应的输出是undefined，没有约束，需要用到索引类型

下面使用索引类型：

function getValue<T,K extends keyof T>(obj: T, keys: K[]): T[K][] { // T[k][]表示，返回值必须是obj中的值组成的列表
   return keys.map(key => obj[key]); // 此时keys中的元素只能是obj中的键
}
console.log(getValue(obj,["a","b"]));
console.log(getValue(obj,["c","f"])); // 这时就会报错，有了约束 'f' is not in "a" | "b" | "c"

我们来解释一下：

这里会用到两个操作符，查询操作符 keyof T 和 访问操作符 T[k]（看下面示例）。<T, K extends keyof T> 用到了泛型约束，表示K所约束的参数的值只能是T所约束参数数据中的“键”。

// keyof T
interface Obj{
   a: number;
   b: string;
}
let key: keyof Obj; // 此时key表示 'a' | 'b'

// T[k]
let value: Obj['a'] // number

映射类型

可以从旧的类型生成新的类型。比如，将接口中的所有成员变成只读、可选。

TS内置了很多映射类型。

interface Obj{
   a: string;
   b: number;
   c: boolean;
}
// 将Obj接口中每个成员变成只读属性，生成一个新的接口。
type ReadonlyObj = Readonly<Obj>;  // Readonly是TS内置的映射类型，下同
// Readonly实现原理，利用了索引类型的操作方法
type Readonly<T> = {
   readonly [P in keyof T]: T[P];
}

再如：

// 将所有属性变成可选
type PartialObj = Partial<Obj>;
// Partial实现原理
type Partial<T> = {
   [P in keyof T]?: T[P];
}

// 获取原类型的子集
type PickObj = Pick<Obj,'a'|'b'>;
// 等同于
interface PickObj {
   a: string,
   b: number
}

// 将原类型当做新类型的成员
type RecordObj = Record<'x'|'y',Obj>;
// 等同于
interface RecordObj {
   x: Obj,
   y: Obj,
}

沙发

条件类型

条件类型指由表达式所决定的类型。条件类型使类型具有了不唯一性，增加了语言的灵活性。

例如：

T extends U ? X : Y   表示如果类型T可以被赋值给类型U，name结果就赋予X类型，否则赋予Y类型

再如：

type TypeName<T> =
   T extends string ? string :
   T extends number ? number :
   T extends boolean ? boolean :
   T extends undefined ? undefined :
   T extends Function ? Function :
   object;

type T1 = TypeName<string>;   // T1为字符串类型
type T2 = TypeName<string[]>; // T2为object类型
type T3 = TypeName<Function>; // T3为function类型
type T4 = TypeName<string | string[]>; // T4为 string和object的联合类型

可以用来做什么？

(A | B) extends U ? X : Y
解析为(A extends U ? X : Y) | (B extends U ? X : Y)

可以利用这一特性做类型的过滤，例如：

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

type T5 = Diff< 'a'|'b'|'c', 'a'|'e' >; // 作用是过滤掉第一个参数中的'a' 。T5为 'b' | 'c'联合类型
解析过程：
 Diff<'a', 'a'|'e'> | Diff<'b', 'a'|'e'> | Diff<'c', 'a'|'e'>
 never | 'b' | 'c'
 'b' | 'c'

TS内置的条件类型：

Exclude<T, U>  // 从T中剔除可以赋值给U的类型，相当于上面例子中的Diff
Extract<T, U>  // 提取T中可以赋值给U的类型。
NonNullable<T>  // 从T中剔除null和undefined。
ReturnType<T>   // 获取函数返回值类型。
InstanceType<T>  // 获取构造函数类型的实例类型。