组合类型与类型保护_TypeScript笔记9
一.组合类型
交叉类型（intersection types）
组合多个类型产生新类型，源类型间存在“与”关系，例如：
interface ObjectConstructor {
assign<T, U>(target: T, source: U): T & U;
}（摘自TypeScript/lib/lib.es2015.core.d.ts）
Object.assign能把source: U身上的可枚举属性浅拷贝到target: T上，因此返回值类型为T & U
交叉类型A & B既是A也是B，因此具有各个源类型的所有成员：
interface A {
a: string;
}
interface B {
b: number
}
let x: A & B;
// 都是合法的
x.a;
x.b;P.S.虽然名字叫intersection（交集），实际上是“求并集”
联合类型（union types）
类似于交叉类型，联合类型由具有“或”关系的多个类型组合而成，例如：
interface DateConstructor {
new (value: number | string | Date): Date;
}（摘自TypeScript/lib/lib.es2015.core.d.ts）
Date构造函数接受一个number或string或Date类型的参数，对应类型为number | string | Date
联合类型A | B要么是A要么是B，因此只有所有源类型的公共成员（“交集”）才能访问：
interface A {
id: 'a';
a: string;
}
interface B {
id: 'b';
b: number
}
let x: A | B;
x.id;
// 错误 Property 'a' does not exist on type 'A | B'.
x.a;
// 错误 Property 'b' does not exist on type 'A | B'.
x.b;二.类型保护
联合类型相当于由类型构成的枚举类型，因而无法确定其具体类型：
联合类型
A | B要么是A要么是B
这在函数签名上没什么问题，但在函数实现中，通常需要区分出具体类型，例如：
let createDate: (value: number | string | Date) => Date;
createDate = function(value) {
let date: Date;
if (typeof value === 'string') {
value = value.replace(/-/g, '/');
// ...
}
else if (typeof value === 'number') {/*...*/}
else if (value instanceof Date) {/*...*/}
return date;
};因此，在此类场景下，需要把“宽”的联合类型，“缩窄”到一个具体类型。从类型角度来看，上面代码在理想情况下应该是这样的：
function(value) {
// 此处，value是联合类型，要么number要么string要么Date
if (typeof value === 'string') {
// 此分支下，value是string
}
else if (typeof value === 'number') {
// 此分支下，value是number
}
else if (value instanceof Date) {
// 此分支下，value是Date
}
// 此处，value是联合类型，要么number要么string要么Date
}也就是说，需要有一种机制能让我们告诉类型系统，“听着，现在我知道这个东西的具体类型了，请把它圈小一些”
而这种机制，就是类型保护（type guard）
A type guard is some expression that performs a runtime check that guarantees the type in some scope.
typeof类型保护
typeof variable === 'type'是用来确定基本类型的惯用手法，因此TypeScript能够识别typeof，并自动缩窄对应分支下的联合类型：
let x: number | string;
if (typeof x === 'string') {
// 正确 typeof类型保护，自动缩窄到string
x.toUpperCase();
}在switch语句，&&等其它分支结构中也同样适用：
switch (typeof x) {
case 'number':
// 正确 typeof类型保护
x.toFixed();
break;
}
// 正确 typeof类型保护
typeof x !== 'number' && x.startsWith('xxx');注意，最后一例很有意思，x要么是number要么是string，从typeof判断得知不是number，因此缩窄到string
具体的，typeof类型保护能够识别两种形式的typeof：
typeof v === "typename"typeof v !== "typename"
并且typename只能是number、string、boolean或symbol，因为其余的typeof检测结果不那么可靠（具体见typeof），所以不作为类型保护，例如：
let x: any;
if (typeof x === 'function') {
// any类型，typeof类型保护不适用
x;
}
if (typeof x === 'object') {
// any类型，typeof类型保护不适用
x;
}P.S.相关讨论，见typeof a === “object” does not type the object as Object
instanceof类型保护
类似于typeof检测基本类型，instanceof用来检测实例与“类”的所属关系，也是一种类型保护，例如：
let x: Date | RegExp;
if (x instanceof RegExp) {
// 正确 instanceof类型保护，自动缩窄到RegExp实例类型
x.test('');
}
else {
// 正确 自动缩窄到Date实例类型
x.getTime();
}具体的，要求instanceof右侧是个构造函数，此时左侧类型会被缩窄到：
- 该类实例的类型（构造函数
prototype属性的类型） - （构造函数存在重载版本时）由构造函数返回类型构成的联合类型
例如：
// Case1 该类实例的类型
let x;
if (x instanceof Date) {
// x从any缩窄到Date
x.getTime();
}
// Case2 由构造函数返回类型构成的联合类型
interface DateOrRegExp {
new(): Date;
new(value?: string): RegExp;
}
let A: DateOrRegExp;
let y;
if (y instanceof A) {
// y从any缩窄到RegExp | Date
y;
}P.S.关于instanceof类型保护的更多信息，见4.24 Type Guards
P.S.另外，class具有双重类型含义，在TypeScript代码里的体现形式如下：
- 类的类型：
typeof className - 类实例的类型：
typeof className.prototype或者className
例如：
class A {
static prop = 'prop';
id: 'b'
}
// 类的类型
let x: typeof A;
x.prop;
// 错误 id是实例属性，类上不存在
x.id;
// 类实例的类型
let y: typeof A.prototype;
let z: A;
// 二者类型等价
z = y;
// 错误 prop是静态属性，实例上不存在
z.prop;
z.id;也就是说，类实例的类型等价于构造函数prototype属性的类型。但这仅在TypeScript的编译时成立，与JavaScript运行时概念有冲突：
class A {}
class B extends A {}
// 构造函数prototype属性是父类实例，其类型是父类实例的类型
B.prototype instanceof A === true自定义类型保护
typeof与instanceof类型保护能够满足一般场景，对于一些更加特殊的，可以通过自定义类型保护来缩窄类型：
interface RequestOptions {
url: string;
onSuccess?: () => void;
onFailure?: () => void;
}
// 自定义类型保护，将参数类型any缩窄到RequestOptions
function isValidRequestOptions(opts: any): opts is RequestOptions {
return opts && opts.url;
}
let opts;
if (isValidRequestOptions(opts)) {
// opts从any缩窄到RequestOptions
opts.url;
}自定类型保护与普通函数声明类似，只是返回类型部分是个类型谓词（type predicate）：
parameterName is Type其中parameterName必须是当前函数签名中的参数名，例如上面的opts is RequestOptions
调用带类型谓词的函数后，传入参数的类型会被缩窄到指定类型，与前两种类型保护行为一致：
let isNumber: (value: any) => value is number;
let x: string | number;
if (isNumber(x)) {
// 缩窄到number
x.toFixed(2);
}
else {
// 不是number就是string
x.toUpperCase();
}三.Nullable与联合类型
TypeScript里空类型（Void）有两种：Undefined与Null，是（除Never外）其它所有类型的子类型。因此null和undefined可以赋值给其它任何类型：
let x: string;
x = null;
x = undefined;
// 运行时错误，编译时不报错
x.toUpperCase();从类型上看，Nullable类型相当于原类型与null | undefined组成的联合类型（上例中，相当于let x: string | null | undefined;）
这意味着类型检查不那么十分可靠，因为仍无法避免undefined/null.xxx之类的错误
strictNullChecks
针对空类型的潜在问题，TypeScript提供了--strictNullChecks选项，开启之后会严格检查空类型：
let x: string;
// 错误 Type 'null' is not assignable to type 'string'.
x = null;
// 错误 Type 'undefined' is not assignable to type 'string'.
x = undefined;对于可以为空的类型，需要显式声明：
let y: string | undefined;
y = undefined;
// Type 'null' is not assignable to type 'string | undefined'.
y = null;同时，可选参数和可选属性会自动带上| undefined，例如：
function createDate(value?: string) {
// 错误 Object is possibly 'undefined'.
value.toUpperCase();
}
interface Animal {
color: string;
name?: string;
}
let x: Animal;
// 错误 Type 'undefined' is not assignable to type 'string'.
x.color = undefined;
// 错误 Object is possibly 'undefined'.
x.name.toUpperCase();类似的空值相关问题都能够暴露出来，由此看来，空类型严格检查相当于一种编译时检查追溯空值的能力
!后缀类型断言
既然Nullable类型实质上是联合类型，那么同样面临类型缩窄的问题。对此，TypeScript也提供了符合直觉的类型保护：
function createDate(value: string | undefined) {
// 缩窄到string
value = value || 'today';
value.toUpperCase();
}对于自动类型保护无法处理的场景，可以简单地通过!后缀去掉| undefined | null成分：
function fixed(name: string | null): string {
function postfix(epithet: string) {
// 通过!去掉类型中的null成分，使之缩窄到string
return name!.charAt(0) + '. the ' + epithet; // ok
}
name = name || "Bob";
return postfix("great");
}identifier!相当于类型断言（不同于类型保护）：
let x: string | undefined | null;
x!.toUpperCase();
// 相当于
(<string>x).toUpperCase();
// 或者
(x as string).toUpperCase();
// Object is possibly 'null' or 'undefined'.
x.toUpperCase();P.S.类型断言与类型保护的区别在于，断言是一次性的（或者说是临时的），而类型保护在一定作用域下都有效
参考资料
- Advanced Types