TS 文档是有一章叫高级类型，其实并不是真的“高级”，他实际的意思是将普通的类型用“某种方式”组合起来形成一个“组合类型”，这个组合类型叫高级类型。对于这种组合后的类型可以有一些特殊的操作。
交叉类型
交叉类型就是一个高级类型的典型，它表示多种类型取并集组成的一个类型。
interface First {
a: number;
b: number;
}
interface Second {
a: number;
c: number;
}
function mix():First & Second {
const result = {
a: 1,
b: 2,
c: 3
}
return result
}
mix() // {a: 1, b: 2, c: 3}
上面将 First 和 Second 交叉在了一起，相当于对两个 interface 的属性取并集，取完并集的新类型就是交叉类型。
联合类型
联合类型就是多种类型选其一。
function add(a: number|string, b: number|string) {
}
上面函数的参数的类型可以为 number 或者 string，这就比单单一个 string 或者单单一个 number 类型要高级，因为这里可以选呀。
类型保护与区分类型
这个特性就是要怎么判断好一个变量的类型。先来回顾一下 JS 里的 7 种基本类型：number, string, boolean, object, null, undefined, symbol。
typeof 保护
使用 typeof 做类型检测和以前写 JS 一样。以上面的加法函数为例。
function add(a: number|string, b: number|string) {
if (typeof a === 'number' && typeof b === 'number') {
console.log(a + b)
}
if (typeof a === 'string' && typeof b === 'string') {
console.log(parseInt(a) + parseInt(b))
}
}
这里代码是有点啰嗦，主要突出 typeof 的使用。
instanceof 保护
typeof 有个缺点就是不能将 object 细分，比如要 typeof Date 类型和 RegExp 类型，结果总是 'object'，不能再细分了。instanceof 就可以完美解决，它后面跟的是一个构造函数，可以判断当前变量是否属于这个构造函数。
function printDate(a: Date|String) {
if (a instanceof Date) {
console.log(a.toDateString())
}
else if (a instanceof String){
console.log(a.toString())
}
}
printDate(new Date()) // "Thu Mar 14 2019"
printDate(new String("2019/1/2")) // "2019/1/2"
上面是根据传入不同的对象来打印时间的函数。
自定义保护
上面 typeof 和 instanceof 都是 JS 提供判断类型的方法，当然我们也可以自己去实现。
interface Bird {
fly();
}
interface Fish {
swim();
}
function isFish(pet: Fish | Bird): pet is Fish {
return (<Fish>pet).swim !== undefined;
}
上面就定义了一个函数去判断传入参数是属于 Bird 还是 Fish，这里判断的依据是看变量是否含有 swim 方法。后面写 if-else 语句就可以调用这个函数了。
function doSth(pet: Fish|Bird) {
if (isFish(pet)) {
pet.swim();
}
else {
pet.fly();
}
}
let pet1:Fish = {
swim() {
console.log('Swimming....')
}
}
let pet2:Bird = {
fly() {
console.log('Flying....')
}
}
doSth(pet1) // 'Swimming'
doSth(pet2) // 'Flying'
类型别名
使用 type 关键字可以定义别名。
type RC = React.Component
class A extends React.Component {
}
type Phone = string | number
type Human = {
name: string
age: number
}
它的作用就是可以不需要每次都写那么多的字。由于是“别名”，所以 Phone，Human 都是指代等号后面那一堆东西，在引用的时候不要别名看成是一个变量，而是要看成后面那一堆东西。
function setPhone(phone: Phone) {
}
// 要看成是
function setPhone(phone: string|number) {
}
这其实也是 interface 和 type 的一个主要区别，interface 是真实存在的，而 type 只是一个名字。
字符串字面量
这个和枚举差不多，有点像联合类型的用法。
type Dir = 'up' | 'down' | 'left' | 'right'
let d: Dir = 'up2' // 报错
type Dice = 1 | 2 | 3 | 4 | 5 | 6
type dice: Dice = 2
可辨识联合
一句话总结是就是对不同对象的相同属性进行判断，根据判断结果做对应的事。
interface Square {
kind: "square";
size: number;
}
interface Rectangle {
kind: "rectangle";
width: number;
height: number;
}
interface Circle {
kind: "circle";
radius: number;
}
上面先定义了三个不同的 interface，它们都有相同的属性 "kind"。为了方便，再定义一个 type。
type Shape = Square | Rectangle | Circle;
下面就是可辨识联合，就是写判断语句去判断 "kind" 的值来求对应的面积。
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.radius ** 2;
}
}
完整性检查
有可能程序员偷懒不想全都检查所有 kind 的值，那可以在 default 那里抛出错误，返回值是 never，表示不会存在。
function assertNever(x: never): never {
throw new Error("Unexpected object: " + x);
}
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.radius ** 2;
default: return assertNever(s); // error here if there are missing cases
}
}
如果传入对象 kind: "triangle" 那么不会得到一个具体的值，同时也会报错来提示传入对象不对。
