TyepScript入门之进阶篇
现在我们学习TypeScript的进阶部分。我学习TypeScirpt的目的是因为我发现React js的源码是用TypeScript写的，所以为了能看懂源码，很有必要学习TypeScript.
类型别名
类型别名是用来给一个类型七个新名字。比如我们可以给类型string起名为name.
一个简单的例子：
type name = string;//原始类型string 定义为name
type age = number;//原始类型number 定义为age
type NameResolver = () =>string; //一个输入为空，输出为string的函数定义为`NameResolver`类型。
type NameOrResolver = name | NameResolver;//联合类型定义为`NameOrResolver`
let n:name = "aa";
let a:age = 1;
let nn:NameResolver = ()=> "a";
function getName(n:NameOrResolver):name {
if(typeof n === 'string'){
return n;
}else{
return n();
}
}
在上面的例子中，我们使用type创建类型别名。类型别名常用于创建联合类型。
我们在源码的node_modules/@types/react/index.d.ts里看到：这种类型别名的用法。
type NativeAnimationEvent = AnimationEvent;
type NativeClipboardEvent = ClipboardEvent;
type NativeCompositionEvent = CompositionEvent;
...
字符串字面量类型
字符串字面量类型用来约束取值只能是某几个字符串中的一个。
一个简单的例子：
type EventNames = 'click' | 'scroll' | 'mousemove';
function handleEvent(ele: Element, event: EventNames) {
// do something
}
handleEvent(document.getElementById('hello'), 'scroll'); // 没问题
handleEvent(document.getElementById('world'), 'dbclick'); // 报错，event 不能为 'dbclick'
在上面的例子中，我们使用了type定了一个字符串字面量类型EventNames,它只能取三种字符串中的一种。
我们需要注意的是：类型别名与字符串字面量类型都是使用type来定义。
元组
数组合并了相同类型的对象。而元组Tuple合并了不同类型的对象。
一个简单的例子：
定义一对值分别为string和number的元组：
let xcatliu:[string,number] = ['Xcat Liu',25];
当赋值或访问一个已知索引的元素时，会得到正确的类型：
let xcatliu:[string,number];
xcatliu[0] = 'Xcat liu';
xcatliu[1] = 25;
xcatliu[0].slice(1);
xcatliu[1].toFixed(2);
也可以只赋值一项：
let xcatliu:[string,number];
xcatliu[0] = 'Xcat liu';
但是当直接对元组类型的变量进行初始化或者赋值的时候，需要提供所有元组类型中指定的项。
let xcatliu: [string, number];
xcatliu = ['Xcat Liu', 25];
let xcatliu:[string,number] = ['Xcat liu'];
hello.ts:211:5 - error TS2322: Type '[string]' is not assignable to type '[string, number]'.
Property '1' is missing in type '[string]'.
211 let xcatliu:[string,number] = ['Xcat liu'];
let xcatliu:[string,number];
xcatliu = ['xcat liu'];
xcatliu[1] = 25;
hello.ts:214:1 - error TS2322: Type '[string]' is not assignable to type '[string, number]'.
Property '1' is missing in type '[string]'.
214 xcatliu = ['xcat liu'];
~~~~~~~
超界的元素
当添加越界的元素时，它的类型会被限制为元组中每个类型的联合类型：
let xcatliu:[string,number] = ['cat',25];
xcatliu.push("aaaa");
xcatliu.push(true);
hello.ts:219:14 - error TS2345: Argument of type 'true' is not assignable to parameter of type 'string | number'.
219 xcatliu.push(true);
枚举
枚举Enum，我们非常熟悉的java里有的。枚举类型用于取值被限定在一定范围内的场景，例如一个星期有七天，红绿灯只有三种颜色，红，黄，绿等。
一个简单的例子：
枚举使用enum关键字定义：
enum Days {Sun,Mon,Tue,Wed,Thu,Fri,Sat};
console.log(Days["Sun"] === 0);
console.log(Days["Mon"] === 1);
console.log(Days["Tue"] === 2);
console.log(Days["Wed"] === 3);
console.log(Days[0] === "Sun");
console.log(Days[1] === "Mon");
console.log(Days[2] === "Tue");
console.log(Days[3] === "Wed");
运行命令：的执行结果为：
ts-node hello.ts
让我们看一下他们的js实现。也即是编译之后的结果。
var Days;
(function (Days) {
Days[Days["Sun"] = 0] = "Sun";
Days[Days["Mon"] = 1] = "Mon";
Days[Days["Tue"] = 2] = "Tue";
Days[Days["Wed"] = 3] = "Wed";
Days[Days["Thu"] = 4] = "Thu";
Days[Days["Fri"] = 5] = "Fri";
Days[Days["Sat"] = 6] = "Sat";
})(Days || (Days = {}));
手动赋值
我们也可以给枚举手动赋值：
enum Days {Sun = 7,Mon = 1,Tue,Wed,Thu,Fri,Sat};
console.log(Days["Sun"] === 7); // true
console.log(Days["Mon"] === 1); // true
console.log(Days["Tue"] === 2); // true
console.log(Days["Sat"] === 6); // true
在面的例子中，我们给Sun赋值为7，Mon赋值为1，而未手动赋值的枚举项会接着上一个枚举递增。
编译后的结果正好可以验证这一点。
var Days;
(function (Days) {
Days[Days["Sun"] = 7] = "Sun";
Days[Days["Mon"] = 1] = "Mon";
Days[Days["Tue"] = 2] = "Tue";
Days[Days["Wed"] = 3] = "Wed";
Days[Days["Thu"] = 4] = "Thu";
Days[Days["Fri"] = 5] = "Fri";
Days[Days["Sat"] = 6] = "Sat";
})(Days || (Days = {}));
如果未手动赋值的枚举项与手动赋值的重复了，目前TypeScript是不会察觉到这一点的：
enum Days {Sun = 3,Mon = 1,Tue,Wed,Thu,Fri,Sat};
console.log(Days["Sun"] === 3); // true
console.log(Days["Wed"] === 3); // true
console.log(Days[3] === "Sun"); // false
console.log(Days[3] === "Wed"); // true
编译的结果可以看到它重复的地方：
var Days;
(function (Days) {
Days[Days["Sun"] = 3] = "Sun";
Days[Days["Mon"] = 1] = "Mon";
Days[Days["Tue"] = 2] = "Tue";
Days[Days["Wed"] = 3] = "Wed";
Days[Days["Thu"] = 4] = "Thu";
Days[Days["Fri"] = 5] = "Fri";
Days[Days["Sat"] = 6] = "Sat";
})(Days || (Days = {}));
在上面的例子中，递增到3的时候与前面的Sun的取值重复了，但是TypeScript并没有报错，导致Days[3]的值先是Sun，而后又被Web覆盖了，造成了上面的编辑结果。
手动赋值的枚举项可以不是数字，此时需要使用类型断言来让tsc无视类型检查(编译出的js仍然是可用的)：
enum Days {Sun =7,Mon,Tue,Wed,Thu,Fri,Sat = <any>"S"};
var Days;
(function (Days) {
Days[Days["Sun"] = 7] = "Sun";
Days[Days["Mon"] = 8] = "Mon";
Days[Days["Tue"] = 9] = "Tue";
Days[Days["Wed"] = 10] = "Wed";
Days[Days["Thu"] = 11] = "Thu";
Days[Days["Fri"] = 12] = "Fri";
Days[Days["Sat"] = "S"] = "Sat";
})(Days || (Days = {}));
如果，手动赋值的枚举项是小数或者负数也是可以的，此时后续未手动赋值的项的递增步长扔为 1 ：
var Days;
(function (Days) {
Days[Days["Sun"] = 7] = "Sun";
Days[Days["Mon"] = 1.5] = "Mon";
Days[Days["Tue"] = 2.5] = "Tue";
Days[Days["Wed"] = 3.5] = "Wed";
Days[Days["Thu"] = 4.5] = "Thu";
Days[Days["Fri"] = 5.5] = "Fri";
Days[Days["Sat"] = 6.5] = "Sat";
})(Days || (Days = {}));
常数项和计算所得项
枚举项有两种类型：常数项(constant member) 和 计算所得项 (computed member)
前面我们所举的例子都是常数项，一个典型的计算所得项的例子：
enum Color {Red,Green,Blue="blue".length};
在上面的例子中，"blue".length就是一个计算所得项。
上面的例子不会报错。但是如果紧接在计算所得项后面的是未手动赋值的项，那么它就会因为无法获得初始值而报错：
enum Color {Red = "red".length,Green,Blue};
hello.ts:255:32 - error TS1061: Enum member must have initializer.
255 enum Color {Red = "red".length,Green,Blue};
~~~~~
hello.ts:255:38 - error TS1061: Enum member must have initializer.
255 enum Color {Red = "red".length,Green,Blue};
下面是常数项和计算所得项的完整定义，部分引用自中文手册 - 枚举：
当满足以下条件时，枚举成员被当作是常数：
- 不具有初始化函数并且之前的枚举成员是常数。在这种情况下，当前枚举成员的值为上一个枚举成员的值加 1。但第一个枚举元素是个例外。如果它没有初始化方法，那么它的初始值为 0。
- 枚举成员使用常数枚举表达式初始化。常数枚举表达式是 TypeScript 表达式的子集，它可以在编译阶段求值。当一个表达式满足下面条件之一时，它就是一个常数枚举表达式：
数字字面量
引用之前定义的常数枚举成员（可以是在不同的枚举类型中定义的）如果这个成员是在同一个枚举类型中定义的，可以使用非限定名来引用
带括号的常数枚举表达式
+, -, ~ 一元运算符应用于常数枚举表达式
+, -, *, /, %, <<, >>, >>>, &, |, ^ 二元运算符，常数枚举表达式做为其一个操作对象。若常数枚举表达式求值后为NaN或Infinity，则会在编译阶段报错
所有其它情况的枚举成员被当作是需要计算得出的值。
常数枚举
常数枚举是使用const enum定义的枚举类型：
const enum Directions {Up,Down,Left,Right};
let directions = [Directions.Up,Directions.Down,Directions.Left,Directions.Right];
常数枚举与普通枚举的区别是，它会在编译阶段被删除，并且不能包含计算成员。
上面的编译结果是：
var directions = [0 /* Up */, 1 /* Down */, 2 /* Left */, 3 /* Right */];
假如包含了计算成员，则会在编译阶段报错：
const enum Color {Red,Green,Blue = "blue".lenght};
// index.ts(1,38): error TS2474: In 'const' enum declarations member initializer must be constant expression.
外部枚举
外部枚举Ambient Enums是使用declare enum定义的枚举类型：
declare enum Directions {
Up,
Down,
Left,
Right
}
let directions = [Directions.Up,Directions.Down,Directions.Left,Directions.Right];
之前提到过，declare定义的类型只会用于编译时的检查，编译结果中会被删除。
上面的编译结果是：
var directions = [Directions.Up, Directions.Down, Directions.Left, Directions.Right];
外部枚举与声明语句一样，常出现在声明文件中。
同时使用declare和const也是可以的：
declare const enum Directions {
Up,
Down,
Left,
Right
}
let directions = [Directions.Up, Directions.Down, Directions.Left, Directions.Right];
编译结果是：
var directions = [0 /* Up */, 1 /* Down */, 2 /* Left */, 3 /* Right */];
类
在传统方法中，JavaScript通过构造函数实现类的概念，通过原型链实现继承，而在ES6中，我们终于迎来了class。
TypeScript除了实现了所有ES6中的类的功能以外，还添加了一些新的用法。
类的概念
虽然 JavaScript 中有类的概念，但是可能大多数 JavaScript 程序员并不是非常熟悉类，这里对类相关的概念做一个简单的介绍。
- 类(Class)：定义了一件事物的抽象特点，包含它的属性和方法
- 对象（Object）：类的实例，通过 new 生成
- 面向对象（OOP）的三大特性：封装、继承、多态
- 封装（Encapsulation）：将对数据的操作细节隐藏起来，只暴露对外的接口。外界调用端不需要（也不可能）知道 细节，就能通过对外提供的接口来访问该对象，同时也保证了外界无法任意更改对象内部的数据
- 继承（Inheritance）：子类继承父类，子类除了拥有父类的所有特性外，还有一些更具体的特性
- 多态（Polymorphism）：由继承而产生了相关的不同的类，对同一个方法可以有不同的响应。比如 Cat 和 Dog 都继承自 Animal，但是分别实现了自己的 eat 方法。此时针对某一个实例，我们无需了解它是 Cat 还是 Dog，就可以直接调用 eat 方法，程序会自动判断出来应该如何执行 eat
- 存取器（getter & setter）：用以改变属性的读取和赋值行为
- 修饰符（Modifiers）：修饰符是一些关键字，用于限定成员或类型的性质。比如 public 表示公有属性或方法
- 抽象类（Abstract Class）：抽象类是供其他类继承的基类，抽象类不允许被实例化。抽象类中的抽象方法必须在子类中被实现
- 接口（Interfaces）：不同类之间公有的属性或方法，可以抽象成一个接口。接口可以被类实现（implements）。一个类只能继承自另一个类，但是可以实现多个接口
关于类在ES6中的用法，这里不在介绍，大家可以查看ECMAScript 6 入门 - Class。
下面我们看一下在TypeScript中类的用法。
TypeScript 中类的用法
熟悉的 public private protected
TypeScript可以使用三种访问修饰符，分别是public 、private 、和 protected。
-
public修饰的属性或方法是公有的，可以在任何地方被访问到，默认所有的属性和方法都是public的 -
private修饰的属性或方法是私有的，不能在声明它的类的外部访问 -
protected修饰的属性或方法是受保护的，它和private类似，区别是它在子类中也是允许被访问的
class Animal {
public name;
public constructor(name) {
this.name = name;
}
}
let a = new Animal('Jack');
console.log(a.name); // Jack
a.name = 'Tom';
console.log(a.name); // Tom
上面的例子中，name 被设置为了 public，所以直接访问实例的 name 属性是允许的。
很多时候，我们希望有的属性是无法直接存取的，这时候就可以用 private 了：
class Animal {
private name;
public constructor(name) {
this.name = name;
}
}
let a = new Animal('Jack');
console.log(a.name); // Jack
a.name = 'Tom';
// index.ts(9,13): error TS2341: Property 'name' is private and only accessible within class 'Animal'.
// index.ts(10,1): error TS2341: Property 'name' is private and only accessible within class 'Animal'.
需要注意的是，TypeScript 编译之后的代码中，并没有限制 private 属性在外部的可访问性。
上面的例子编译后的代码是：
var Animal = (function () {
function Animal(name) {
this.name = name;
}
return Animal;
}());
var a = new Animal('Jack');
console.log(a.name);
a.name = 'Tom';
使用 private 修饰的属性或方法，在子类中也是不允许访问的：
class Animal {
private name;
public constructor(name) {
this.name = name;
}
}
class Cat extends Animal {
constructor(name) {
super(name);
console.log(this.name);
}
}
而如果是用 protected 修饰，则允许在子类中访问：
class Animal {
protected name;
public constructor(name) {
this.name = name;
}
}
class Cat extends Animal {
constructor(name) {
super(name);
console.log(this.name);
}
}
抽象类
抽象类abstract用于定义抽象类和其中的抽象方法。
什么是抽象类呢？
- 抽象类是不背允许被实例化的类
- 抽象类中的方法子类必须实现
下面是抽象类的使用：
abstract class Animal {
public name;
public constructor(name){
this.name = name;
}
public abstract sayHi();
};
class Cat extends Animal {
public sayHi(){
console.log(`Meow, My name is ${this.name}`);
}
}
let cat = new Cat("Tom");
类的类型
给类加上TypeScript的类型很简单，与接口类似：
class Animal {
name:string;
constructor(name:string){
this.name = name;
}
sayHi():string {
return `My name is ${this.name}`
}
}
let a:Animal = new Animal('Tom');
console.log(a.sayHi());
类与接口
之前在TypeScript入门之基础篇。中，接口可以用于对对象形状的描述。
这里我们主要学习接口对行为的描述。
类实现接口
实现（implements）是面向对象中的一个重要概念。一般来讲，一个类只能继承自另一个类，有时候不同类之间可以有一些共有的特性，这时候就可以把特性提取成接口（interfaces），用 implements 关键字来实现。这个特性大大提高了面向对象的灵活性。
举例来说，门是一个类，防盗门是门的子类。如果防盗门有一个报警器的功能，我们可以简单的给防盗门添加一个报警方法。这时候如果有另一个类，车，也有报警器的功能，就可以考虑把报警器提取出来，作为一个接口，防盗门和车都去实现它：
interface Alarm {
alert(); //这里并不是调用函数，而是定义了一个函数
}
class Door {
}
class SecurityDoor extends Door implements Alarm {
alert() {
console.log('SecurityDoor alert');
}
}
class Car implements Alarm{
alert() {
console.log('Car alert')
}
}
同样，一个类可以实现多个接口。
interface Alarm {
alert();
}
interface Light {
lightOn();
lightOff();
}
class Car implements Alarm,Light{
alert() {
console.log('Car alert');
}
lightOff() {
console.log('Car alert off');
}
lightOn() {
console.log('Car alert on');
}
}
接口还可以继承接口
接口与接口之间可以是继承关系：
interface Alarm {
alert();
}
interface LightableAlarm extends Alarm{
lightOn();
lightOff();
}
可以看到上面的接口LightableAlarm继承了Alarm接口。
接口还可以继承类：
class Point {
x:number;
y:number;
}
interface Point3d extends Point{
z:number;
}
let point3d:Point3d = {x:1,y:2,z:3};
混合类型
之前学习过，可以使用接口的方式定义一个函数需要符合的形状，也就是定义它的输入和输出。
interface SearchFunc {
(source:string,subString:string):boolean;
}
let mySearch:SearchFunc;
mySearch = function (source:string,subString:string) {
return source.search(subString) !== -1;
}
有时候，一个函数还可以有自己的属性和方法：
interface Counter {
(start:number):string;
interval:number;
reset():void;
}
function getCounter():Counter {
let counter = <Counter> function (start:number){};
counter.interval = 123;
counter.reset = function () {};
return counter;
}
let c = getCounter();
c(10);
c.reset();
c.interval = 5.0;
泛型
泛型(Generics)是指在定义函数，接口或类的时候，不预先制定具体的类型，而在使用的时候在制定类型的一种特性。
简单的例子
首先，我们来实现一个函数createArray,它可以创建一个指定长度的数组，同事将每一项都填充一个默认值：
function createArray(length:number,value:any):Array<any> {
let result = [];
for(let i = 0;i<length;i++){
result[i] = value;
}
return result;
}
createArray(3,'x');
上例中，我们使用了之前提到过的数组泛型来定义返回值的类型。
这段代码不会报错，但是它的缺陷是没有准确的定义返回值的类型。
Array<any>允许数组的每一项都为任意类型。但是我们预期的是，数组中每一项都应该是输入的value的类型。
那么，这个时候就该泛型上场了。
function createArray<T>(length:number,value:T):Array<T> {
let result: T[] = [];
for (let i = 0; i < length; i++) {
result[i] = value;
}
return result;
}
createArray<string>(3, 'x'); // ['x', 'x', 'x']
在上面的例子中，我们的函数名后添加了<T>,其中的T用来指代任意输入的类型，在后面的输入value:T和输出Array<T>中即可使用了。
在调用的时候，可以指定它具体的类型为string。当然也可以不指定，而让类型自动推算出来。
function createArray<T>(length:number,value:T):Array<T> {
let result: T[] = [];
for (let i = 0; i < length; i++) {
result[i] = value;
}
return result;
}
// createArray<string>(3, 'x'); // ['x', 'x', 'x']
createArray(3,"x");
多个类型参数
定义泛型的时候，可以一次定义多个类型参数：
function swap<T, U>(tuple: [T, U]):[U,T] {
return [tuple[1],tuple[0]]
}
swap([7,'seven'])
在上面的代码中，我们定义了一个swap函数，用来交换输入的元组。
泛型的约束
在函数内部使用泛型变量的时候，由于事先不知道它是哪种类型，所以不能随意的操作它的属性或方法：
function loggingIdentity<T>(arg:T):T {
console.log(arg.length);
return arg;
}
hello.ts:431:21 - error TS2339: Property 'length' does not exist on type 'T'.
431 console.log(arg.length);
上面的代码中，泛型T不一定包含属性length，所以编译的时候报错了。
这个时候我们就需要对泛型进行约束，只允许这个函数传入那些包含length属性的变量，这就是泛型的约束：
interface Lengthwise {
length:number
}
function loggingIdentity<T extends Lengthwise>(arg:T):T {
console.log(arg.length);
return arg;
}
我们通过使用extends约束了泛型T必须符合接口Lengthwise的形状，也就是必须包含length属性。
这个时候调用loggingIdentity的时候，传入的arg不包含length，那么在编译阶段就会报错了。
interface Lengthwise {
length:number
}
function loggingIdentity<T extends Lengthwise>(arg:T):T {
console.log(arg.length);
return arg;
}
loggingIdentity(7);
hello.ts:439:17 - error TS2345: Argument of type '7' is not assignable to parameter of type 'Lengthwise'.
439 loggingIdentity(7);
多个类型参数之间也可以互相约束：
function copyFields<T extends U, U>(target: T, source: U): T {
for (let id in source) {
target[id] = (<T>source)[id];
}
return target;
}
let x = { a: 1, b: 2, c: 3, d: 4 };
copyFields(x, { b: 10, d: 20 });
泛型接口
之前学习过，可以使用接口的方式来定义一个函数需要符合的形状：
interface SearchFunc {
(source:string,subString:string):boolean;
}
let mySearch:SearchFunc = function (source:string,subString:string) {
return source.search(subString)!== -1;
}
我们一样可以使用含有泛型的接口来定义函数的形状：
interface CreateArrayFunc {
<T>(length:number,value:T):Array<T>;
}
let createArray:CreateArrayFunc;
createArray = function <T>(length:number,value:T):Array<T> {
let result:T[] = [];
for(let i = 0;i<length;i++){
result[i] = value;
}
return result;
}
createArray(3,'x');
进一步的话，我们可以把泛型参数提前到接口名上：
interface CreateArrayFunc<T> {
(length: number, value: T): Array<T>;
}
let createArray: CreateArrayFunc<any>;
createArray = function<T>(length: number, value: T): Array<T> {
let result: T[] = [];
for (let i = 0; i < length; i++) {
result[i] = value;
}
return result;
}
createArray(3, 'x'); // ['x', 'x', 'x']
注意，此时在使用泛型接口的时候，需要定义泛型的类型。
泛型类
与泛型接口类似，泛型也可以用于类的类型定义中：
class GenericNumber<T> {
zeroValue: T;
add: (x: T, y: T) => T;
}
let myGenericNumber = new GenericNumber<number>();
myGenericNumber.zeroValue = 0;
myGenericNumber.add = function(x, y) { return x + y; };
泛型参数的默认类型
在 TypeScript 2.3 以后，我们可以为泛型中的类型参数指定默认类型。当使用泛型时没有在代码中直接指定类型参数，从实际值参数中也无法推测出时，这个默认类型就会起作用。
function createArray<T = string>(length: number, value: T): Array<T> {
let result: T[] = [];
for (let i = 0; i < length; i++) {
result[i] = value;
}
return result;
}
over...
