类型约束
type A<T extends U>
我们可以理解为将 T 类型限制或者约束为 U 类型
- 对于普通字面量类型来说
type Z<T extends 0> = T // 这里限制了 T的类型为字面量类型0
var z: Z<0> // 所以这里我们只能传入0
var z: Z<1> // 如果我们传入的不是0，就会报错 “类型1不满足约束类型0”
- 对于对象类型
type Z<T extends {id: number}> = T
// 正确的类型
var z: Z<{id: 1}> // 只传入 id
var z1: Z<{id: 1, name: 'lifa'}> // 传入id和其他字段
// 错误的类型
var z2: Z<{name: 'xxx'}> // 没有传入id 报错“类型 {name: "xxx"} 不满足约束 {id: number}”
对象类型的约束必须至少包含约束里的属性，也可以额外加入属性
- 对于 boolean 类型或者联合类型
boolean 就相当于联合类型 true | false
所以 boolean 类型的约束就只能是 true | false
type Z<T extends boolean> = T
var z: Z<false>
var z1: Z<true>
var z2: Z<true | false>
注意
尽可能使用类型参数本身，而不是去约束它
比如：
function firstElement1<Type>(arr: Type[]) {
return arr[0];
}
function firstElement2<Type extends any[]>(arr: Type) {
return arr[0];
}
// a: number (good)
const a = firstElement1([1, 2, 3]);
// b: any (bad)
const b = firstElement2([1, 2, 3]);
上面的情况我们约束类型反而得不到我们想要的实际类型
条件类型
T extends U ? true : false
我们可以理解为 T 类型能否赋值给U类型，能就走true，否则就走false
- 对于普通字面量类型
我们想要走到正确的分支T是什么类型，U就得是什么类型
type Z<T, U> = T extends U ? true : false
var z1: Z<1, 2> // false
var z2: Z<1, 1> // true
- 对于对象类型
如果想要走到正确分支 T 里面必须至少包含所有 U 里的类型
type Z<T, U> = T extends U ? true : false
// T 和 U 里的类型完全一样
var z1: Z<{id: 1}, {id: 1}> // true
// T 里除了 U 里的 id: 1，还多了 name: 'ff'
var z3: Z<{id: 1, name: 'ff'}, {id: 1}> // true
// T 里缺少U 里的 name:'ff' 类型，所以走到了 false
var z2: Z<{id: 1}, {id: 1, name: 'ff'}> // false
- 对于boolean 类型和联合类型
如果泛型没有被T[]和[T]以及Promise<T>包装过则该条件类型会走分布式条件类型
对于分布式条件类型如果传入的类型是联合类型会被分解成多个分支
1). 没有被T[]和[T]以及Promise<T>包装过的联合
type Z<T, U> = T extends U ? true : false
var z1: Z<1 | 2 | 3, 3 | 4>
// 就会变成
var z1: Z<1, 3> | Z<2, 3> | Z<3,3> | Z<1, 4> | Z<2, 4> | Z<3, 4>
// false | false | true | false | false | false => boolean
注意：只要在条件语句中将泛型变成了 [T] 那么后面所有用到的 T 就都是一个整体
比如：
type Test1<T, U = T> = [U] extends [never] ? [] : T extends U ? T : U
type zz = Test1<'1' | '2' | '3', '1'|'2'>
上面代码前面将 U 使用了 [U] 作为一个整体，所以后面的所有的泛型 U 都是一个整体 '1' | '2'，而T没有被包装过所以 T 会生成多个分支也就是
type zz = Test1<'1', '1' | '2'> | Test1<'2', '1' | '2'> | Test1<'3', '1' | '2'>
'1' | '2'
2). 被T[]包装过的可以当成普通的联合类型
type Z<T, U> = T[] extends U ? true : false
// 1 | 2 | 3 能否赋值给 3 -> false
var z1: Z<1 | 2 | 3, 3> // false
var z2: Z<1 | 2 | 3, 2 | 3> // false
// 因为 T 被T[]了但是 U 没有所以 U 还是走多个分支
// 1 | 2 | 3 能否赋值给 2 -> false
// 1 | 2 | 3 能否赋值给 3 -> false
var z2: Z<1 | 2 | 3, 2> | Z<1 | 2 | 3, 3>
这里要注意所谓的 T[] 和 [T]，只是一个简单的表示如果，也就是只要是这个结构的都可以，比如 T[number] 也属于 T[]
type A<T extends readonly any[], U> = U extends T[number] ? true : false
// 1 extends 1 | 2 | 3 -> true
type B<T extends readonly any[], U> = T[number] extends U ? true : false
// 1 | 2 | 3 extends 1 -> false
var a1: A<[1,2,3], 1> // true
var a2: B<[1,2,3], 1> // false
接口继承
interface A extends interface B
就相当于 A & B
