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...