Typescript笔记：高级类型

ts中的高级类型

交叉类型
联合类型
类型保护和区分类型
可辨识联合
索引类型

交叉类型

使用&将多个类型合并成一个类型。例如Person&Serializable&Loggable同时是Person、Serializable、Loggable，它包含了所有类型的特性。

我们大多是在混入（mixins）或其它不适合典型面向对象模型的地方看到交叉类型的使用。

function extend<T,U>(first:T,second:U):T & U {
	//result断言为交叉类型
	let result = <T & U>{};
	for(let id in first) {
		(<any>result)[id] = (<any>first)[id];
	}
	
	for(let id in second) {
		(<any>result)[id] = (<any>second)[id];
	}
	return result;
}

class Person {
	constructor(public name:string) {}
}

interface Loggable {
	log():void;
}

class ConsoleLogger implements Loggable {
	log(){
		//...
	}
}

var jim = extend(new Person("Jim"),new ConsoleLogger());
var n = jim.name;
jim.log();

上述的extend函数可接收两个参数类型，输出的reslut是交叉类型。所有jim有name属性、也有log()方法

联合类型

联合类型与交叉类型很有关联，但事实上却完全不同。交叉类型可以包含当中所有变量的属性和方法、联合类型是访问所以类型都共有的属性和方法。故交叉类型是方法和属性并集、联合类型区的是方法或属性交集

联合类型使用|分割每个类型，所以联合类型number | string | boolean，表示这个值的类型可以是number，string，boolean。如果一个值是联合类型，我们只能访问此联合类型里共有的成员

例子：

interface Bird {
	fly();
	layEggs();
}

interface Fish {
	swim();
	layEggs();
}

function getSmallPet():Fish|Bird {
	//...
}

let pet = getSmallPet();
pet.layEggs(); //ok
pet.swim();	//error

类型保护与区分类型

联合类型适合于哪些值可以为不同类型。当我们想要确切的知道类型是否为Fish时怎么办？JS中常用区分的2个可能值的方法是检查成员是否存在。如之前提及的，我们只能访问联合类型中共同拥有的成员。

为了让联合类型值使用其中类型的特有方法，我们需要使用断言

let pet = getSmallPet();

if(<Fish>Pet).swim) {
	(<Fish>pet).swim();
}else {
	(<Bird>pet).fly();
}

用户自定义类型保护

在上面的例子中，我们不得已使用了多次断言。假如我们一旦检查过类型，就能在之后的每个分支里清楚的知道pet 类型的话就好了

TypeScript里的 类型保护机制让它成为了现实。

function isFish(pet: Fish | Bird): pet is Fish {
    return (<Fish>pet).swim !== undefined;
}

在这个例子里， pet is Fish就是类型谓词。 谓词为 parameterName is Type这种形式， parameterName必须是来自于当前函数签名里的一个参数名。

typeof类型保护

TS可以把typeof识别为一个类型保护。也就是说我们可以直接在代码里检查类型

function padLeft(value:string,padding:string|number) {
	if(typeof padding === "number") {
		return Array(padding + 1).join("")+value
	}
	if(//...) {
		//...
	}
	throw new Error(//..)
}

使用typeof对类型进行检测后，如果结果为true，该类型就会被指定为判断的这个类型。

instanceof类型保护

instanceof类型保护是通过构造函数来细化类型的一种方式。比如，我们借鉴一下之前字符串填充的例子：

interface Padder {
	getPaddingString():string
}

class SpaceRepeatingPadder implements Padder {
	constructor(private numSpaces:number){}
	getPaddingString() {
		return Array(this.numSpaces + 1).join("")
	}
}

class StringPadder implements Padder {
	constructtor(private value:string) {}
	getPaddingString() {
		return this.value;
	}
}

function getRandomPadder() {
    return Math.random() < 0.5 ?
        new SpaceRepeatingPadder(4) :
        new StringPadder("  ");
}

// 类型为SpaceRepeatingPadder | StringPadder
let padder: Padder = getRandomPadder();

if (padder instanceof SpaceRepeatingPadder) {
    padder; // 类型细化为'SpaceRepeatingPadder'
}
if (padder instanceof StringPadder) {
    padder; // 类型细化为'StringPadder'
}

instanceof的右侧要求是一个构造函数，TypeScript将细化为：

此构造函数的 prototype属性的类型，如果它的类型不为 any的话
构造签名所返回的类型的联合
以此顺序。

联合类型可以通过用户自定义的方式，指定为某个类型、也可以通过typeof来保护对象为某个类型、当需要细化为某个对象使用instanceof