TypeScript type/元组/枚举/类/泛型

类型别名 type

类型别名用来给一个类型起个新名字。

type Name = string
type Fn = () => string
type NameOrResolver = Name | Fn;
function getName(n: NameOrResolver): Name {
    if (typeof n === 'string') {
        return n;
    } else {
        return n();
    }
}

类型别名常用于联合类型

字符串字面量类型

字符串字面量类型用来约束取值只能是某几个字符串中的一个。

type Sex = 'male' | 'formale'
let sex: Sex = 'male'

注意，类型别名与字符串字面量类型都是使用 type 进行定义。

元组

数组合并了相同类型的对象，而元组（Tuple）合并了不同类型的对象。

let arr: [string, number] = ['hello', 24]
arr.push('333') // 可行
arr.push(true) // 报错
当添加越界的元素时，它的类型会被限制为元组中每个类型的联合类型

枚举 (Enum)

枚举（Enum）类型用于取值被限定在一定范围内的场景

enum Days {Sun, Mon, Tue, Wed, Thu, Fri, Sat}
// Sun 未初始化值，默认为0，后面的值默认递增1

常数枚举 vs 普通枚举

常数枚举会在编译阶段被删除，并且不能包含计算成员

外部枚举

是使用 declare enum 定义的枚举类型

declare enum Directions {
        Up,
        Down,  
        Left,
}
let directions = [Directions.Up, Directions.Down, Directions.Left  ]

declare 定义的类型只会用于编译时的检查，编译结果中会被删除
上面的编译结果是：

var directions = [Directions.Up, Directions.Down, Directions.Left  ]

类

使用class 定义类，使用 constructor定义构造函数

类的继承

使用 extends 关键字实现继承，子类中使用 super 关键字来调用父类的构造函数和方法。

class Cat extends Animal {
    constructor(name) {
        super(name); // 调用父类的 constructor(name)
        console.log(this.name);
    }
    sayHi() {
        return 'Meow, ' + super.sayHi(); // 调用父类的 sayHi()
    }
}

let c = new Cat('Tom'); // Tom
console.log(c.sayHi()); // Meow, My name is Tom

存取器

使用getter和 setter 可以改变属性的赋值和读取行为

静态方法

使用static 修饰符修饰的方法称为静态方法，不需要实列化，直接通过类来调用

ES7 中类的用法

ES7 中有一些关于类的提案，TypeScript 也实现了它们，这里做一个简单的介绍。

实例属性

ES6 中实例的属性只能通过构造函数中的 this.xxx 来定义，ES7 提案中可以直接在类里面定义：

class Animal {
  name = 'jack'
  constructor () {
    // ...
  }
}
let a = new Animal()
console.log(a.name) // jack

静态属性

ES7 提案中，可以使用 static 定义一个静态属性：

class Animal {
  static num = 42
}
console.log(Animal.num) // 42

TypeScript 中类的用法

修饰符：public private 和 protected

public 修饰的属性或方法是公有的，可以在任何地方被访问到，默认所有的属性和方法都是
private 修饰的属性或方法是私有的，不能在声明它的类的外部访问
protected 修饰的属性或方法是受保护的，它和 private 类似，区别是它在子类中也是允许被访问的

抽象类

abstract 用于定义抽象类和其中的抽象方法

首先，抽象类是不允许被实例化的

abstract class Animal {
    public name;
    public constructor(name) {
        this.name = name;
    }
    public abstract sayHi();
}

let a = new Animal('Jack'); // 报错

其次，抽象类中的抽象方法必须被子类实现

类与接口

接口除了可以对描述对象的形状
也可以对类的一部分行为进行抽象

类实现接口

实现（implements）
一般，一个类只能继承另一个类，有时候不同类之间可以有一些共有的特性，这时候就可以把共有特性提取成接口，用implements 来实现

interface Alarm {
  alert()
}
class Door  {}
class SecruityDorr extends Door implements Alarm {
  alert() {
     ....
  }
}

class Car implements Alarm {
  alert() {
    ...
  }
}

一个类可以实现多个接口

calss Car implements Alarm, Light {
}

接口继承接口

接口与接口之间可以是继承关系

interface Light extends Alarm {
...
}

接口继承类

class Point {
  x: number;
  y: number;
}
interface Point3d extends Point {
  z: number
}
let point3d: Point3d = {x:1, y:1, z: 2}

泛型

泛型（Generics）是指在定义函数、接口或类的时候，不预先指定具体的类型，而在使用的时候再指定类型的一种特性。

function createdArray<T>(length: number, value: T): Array<T> {
  let result: T[] = []
  for (let i =0; i< length; i++) {
    result[i] = value
  }
return result
}

createArray(3, 'xxx') // ['x', 'x', 'x']

多个类型参数

function swap<T, U>(tuple: [T, U]): [U, T] {
  return [ tuple[1], tuple[0] ]
}
swap( [7, 'seven'] ) // ['seven', 7]

泛型约束

在函数内边使用泛型变量的时候，由于事先不知道他是哪种类型，所以不能随意的操作他的属性或方法

interface Lengthwise {
  length: number
}
function loggingIndentity<T extends Lengthwise>(arg: T): T {
  console.log(arg.length)
  return arg
}
// 泛型约束，约束参数有length属性

泛型接口

interface CreateArrayFunc {
  <T>(length: number, value: T): Array<T>
}

还可以这样写

interface CreateArrayFunc<T> {
  (length: number, value: T): Array<T>
}

泛型类

class GnenricNumber<T> {
  zeroValue : T;
  add: (x: T, y: T) => T
}

let demo = new GnenricNumber<number>()
demo.zeroValue = 0
demo.add=(x,y)=>x+y