交叉类型
将多个类型合并成一个类型,去两个类型的并集。与继承的区别是,继承可以有自己的属性,而交叉没有。
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(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](看下面示例)。
// 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; // Readonly是TS内置的映射类型,下同
// Readonly实现原理,利用了索引类型的操作方法
type Readonly = {
readonly [P in keyof T]: T[P];
}
再如:
// 将所有属性变成可选
type PartialObj = Partial;
// Partial实现原理
type Partial = {
[P in keyof T]?: T[P];
}
// 获取原类型的子集
type PickObj = Pick;
// 等同于
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 extends string ? string :
T extends number ? number :
T extends boolean ? boolean :
T extends undefined ? undefined :
T extends Function ? Function :
object;
type T1 = TypeName; // T1为字符串类型
type T2 = TypeName; // T2为object类型
type T3 = TypeName; // T3为function类型
type T4 = TypeName; // T4为 string和object的联合类型
可以用来做什么?
(A | B) extends U ? X : Y
解析为(A extends U ? X : Y) | (B extends U ? X : Y)
可以利用这一特性做类型的过滤,例如:
type Diff = 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的类型,相当于上面例子中的Diff
Extract // 提取T中可以赋值给U的类型。
NonNullable // 从T中剔除null和undefined。
ReturnType // 获取函数返回值类型。
InstanceType // 获取构造函数类型的实例类型。