类型别名
type stringName = string;
const a:stringName;
type Name = string;
type NameFn = ()=> string;
// 函数：左侧输入的是任意类型，右侧返回一个string类型
type NameOrNameFn = Name | NameFn;
function fn(n:NameOrNameFn):Name{
if(typeof n === 'string'){
return n
}else{
return n()
}
}
使用type创建别名
类型别名常用于联合类型。
字符串字面量类型
type EventsName = 'click'|'mousemove'|'scroll';
function EventFn(ele:Element,event:EventsName){
// do sometings
}
EventFn(document.getElementById('hello'),'click'); // ok
EventFn(document.getElementById('hello'),'dbclick');
// 报错，event不能为'dbclick'，只能取3种中的一种
注意，类型别称和字面量类型都是使用type来进行定义
元组
数组合并了相同类型的对象，而元组合并了不同类型的对象。
元组起源于函数编程语言如（F#），这些语言中会频繁使用元组
简单例子
let s = [string,number] = ['213',123];
当赋值或访问一个已知索引的元素时，会得到正确的类型
let tom: [string, number];
tom[0] = 'Tom';
tom[1] = 25;
tom[0].slice(1);
tom[1].toFixed(2);
也可以只赋值其中一项
let tom: [string, number];
tom[0] = 'Tom';
但是当直接对元组类型的变量进行初始化或者赋值的时候，需要提供所有元组类型中指定的项
let tom: [string, number];
tom = ['Tom', 25];
let tom: [string, number];
tom = ['Tom'];
// Property '1' is missing in type '[string]' but required in type '[string, number]'.
越界的元素
当添加越界的元素时，它的类型会被限制为元组中每个类型的联合类型
let tom: [string, number];
tom = ['Tom', 25];
tom.push('male');
tom.push(true);
// Argument of type 'true' is not assignable to parameter of type 'string | number'.
枚举
简单的例子
枚举使用enum关键字来定义
enum Days {
sum,Mon,Thu,Fri,Sat};
枚举成员会被赋值为从0开始递增的数字，同时也会对枚举值到枚举名进行反射映射：
enum Days {
Sun, Mon, Tue, Wed, Thu, Fri, Sat};
console.log(Days["Sun"] === 0); // true
console.log(Days["Mon"] === 1); // true
console.log(Days["Tue"] === 2); // true
console.log(Days["Sat"] === 6); // true
console.log(Days[0] === "Sun"); // true
console.log(Days[1] === "Mon"); // true
console.log(Days[2] === "Tue"); // true
console.log(Days[6] === "Sat"); // true
事实上，上面的例子会被编译为：
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};
console.log(Days['Sun']===7);
未手动赋值的枚举项会接着上一个枚举项递增
enum Days{
Sun=3,Mon=1,Two,Wed}
console.log(Days['Sun']===3) // true
console.log(Days[3]==='Sun') // false
console.log(Days[3]==='Wed') // true
递增到3与前面的Sum的值重复了，导致覆盖了。
手动赋值的枚举项可以不是数字，此时需要使用类型断言来让 tsc 无视类型检查 (编译出的 js 仍然是可用的)：
enum Days = {
Sun=4,Mon,Tue,Wed,Sat=<any>"s"};
常数项和计算所得项
枚举项有两种类型：常数项和计算所得项
enum Color{Red,Greem.Blue ="blue".length};
上面的例子中，"blue".length 就是一个计算所得项
上面的例子不会报错，但是如果紧接在计算所得项后面的是未手动赋值的项，那么它就会因为无法获得初始值而报错
enum Color {Red = "red".length, Green, Blue};
// index.ts(1,33): error TS1061: Enum member must have initializer.
// index.ts(1,40): error TS1061: Enum member must have initializer.
当满足以下条件时，枚举成员被当作是常数：
- 不具有初始化函数并且之前的枚举成员是常数。在这种情况下，当前枚举成员的值为上一个枚举成员的值加
1。但第一个枚举元素是个例外。如果它没有初始化方法，那么它的初始值为0。 - 枚举成员使用常数枚举表达式初始化。常数枚举表达式是 TypeScript 表达式的子集，它可以在编译阶段求值。当一个表达式满足下面条件之一时，它就是一个常数枚举表达式：
- 数字字面量
- 引用之前定义的常数枚举成员（可以是在不同的枚举类型中定义的）如果这个成员是在同一个枚举类型中定义的，可以使用非限定名来引用
- 带括号的常数枚举表达式
+,-,~一元运算符应用于常数枚举表达式+,-,*,/,%,<<,>>,>>>,&,|,^二元运算符，常数枚举表达式做为其一个操作对象。若常数枚举表达式求值后为 NaN 或 Infinity，则会在编译阶段报错
所有其它情况的枚举成员被当作是需要计算得出的值。
常数枚举
常数枚举是使用const enum定义的枚举类型
const enum Directions{
up,
down,
left,
right
};
let dir = [Directions.up,Directions.down,Directions.left,Directions,right];
常数枚举会在编译阶段销毁，不能包含计算成员。
上例编辑的结果是：
var dir = [0,1,2,3]
假如包含了计算成员
const enum Color{
Blue,
Red,
Green:'green'.length
}
// index.ts(1,38): error TS2474: In 'const' enum declarations member initializer must be constant expression.
外部枚举
外部枚举是使用了declare enum 来定义的
declare enum Color{
Blue,
Green,
Yellow
}
let color= [Color.Blue,Color.Green,Color.Yellow]
之前提到过，declare 定义的类型只会用于编译时的检查，编译结果中会被删除。
上例的编译结果是：
var directions = [Directions.Up, Directions.Down, Directions.Left, Directions.Right];
类
传统方式中，JavaScript通过构造函数实现类的概念，通过原型链的方式实现了继承。而在ES6中，终于迎来了class
类的概念
- 类（Class）:定义了一件事物的抽象特定，包含它的属性和方法。
- 对象（Object）:类的实例，通过
new生成 - 面对对象（OOP）：封装，继承，多态
- 继承：子类继承父类，方法属性，子类除了拥有父类的特性外，还有一些更具体的特性
- 多态：由继承产生相关的不同的类，比如Cat和Dog都继承animal,但是分别实现了不同的eat方法，针对与某一个实例，我们无需知道它是dog还是cat，就可以直接调用eat方法，因为程序内部会自动判断。
- 封装：将对数据的操作细节隐藏起来，只暴露对外的接口，外界在调用端不需要知道细节，就能通过对外提供的接口访问该对象，同时也保证了外界无法更改对象内部的数据。
- 存储器（getter& setter）:用以改变属性的读取和赋值行为。
- 修饰符：用来修饰一些关键字，用来限定成员的属性或类型的性质。比如
pulic表示公由属性或方法 - 抽象类： ：抽象类是供其他类继承的基类，抽象类不允许被实例化。抽象类中的抽象方法必须在子类中被实现
- 接口： 不同类之间公有的属性或方法，可以抽象成一个接口。接口可以被类实现（implements）。一个类只能继承自另一个类，但是可以实现多个接口
ES6中类的用法
属性和方法
使用class定义类，使用constructor定义构造函数。
通过new生成新的实例的时候，会自动调用构造函数。
class Animal {
public name;
constructor(name:string){
this.name = name;
}
sayHi():string{
return `My name is ${this.name}`;
}
}
let a = new Animal('Jack');
console.log(a.sayHi()) // My name is Jack
类的继承
使用 extends 关键字实现继承，子类中使用 super 关键字来调用父类的构造函数和方法。
class Dog extends Animal {
constructor(name:string){
super(name); // 调用父类的constructor(name)
console.log(name)
}
sayHi():string{
return 'Meow'+super.sayHi()
}
}
存取器
使用 getter 和 setter 可以改变属性的赋值和读取行为：
class Animal {
constructor(name:string){
this.name = name;
}
get name(){
return 'jack';
}
set name(value){
console.log('setter:'+value)
}
}
静态方法
使用 static 修饰符修饰的方法称为静态方法，它们不需要实例化，而是直接通过类来调用：
class Animal {
static isAnimal(a) {
return a instanceof Animal;
}
}
let a = new Animal('Jack');
Animal.isAnimal(a); // true
a.isAnimal(a); // TypeError: a.isAnimal is not a function
ES7中类的用法
实例属性
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;
constructor() {
// ...
}
}
console.log(Animal.num); // 42
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);
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);
}
}
// index.ts(11,17): error TS2341: Property 'name' is private and only accessible within class 'Animal'.
而如果是用 protected 修饰，则允许在子类中访问：
class Animal {
protected name;
public constructor(name) {
this.name = name;
}
}
class Cat extends Animal {
constructor(name) {
super(name);
console.log(this.name);
}
}
当构造函数修饰为 private 时，该类不允许被继承或者实例化：
class Animal {
public name;
private constructor(name) {
this.name = name;
}
}
class Cat extends Animal {
constructor(name) {
super(name);
}
}
let a = new Animal('Jack');
// index.ts(7,19): TS2675: Cannot extend a class 'Animal'. Class constructor is marked as private.
// index.ts(13,9): TS2673: Constructor of class 'Animal' is private and only accessible within the class declaration.
当构造函数修饰为 protected 时，该类只允许被继承：
class Animal {
public name;
protected constructor(name) {
this.name = name;
}
}
class Cat extends Animal {
constructor(name) {
super(name);
}
}
let a = new Animal('Jack');
// index.ts(13,9): TS2674: Constructor of class 'Animal' is protected and only accessible within the class declaration.
参数属性
修饰符和readonly还可以使用构造函数参数中，等同于类中定义该属性同时给该属性赋值，使代码更简洁
class Animal{
// public name:string;
constructor(pubilc name:string){
// this.name = name;
}
}
readonly
只读属性关键字，只允许出现在属性声明或索引签名或构造函数中
class Animal {
readonly name;
public constructor(name) {
this.name = name;
}
}
let a = new Animal('Jack');
console.log(a.name); // Jack
a.name = 'Tom';
// index.ts(10,3): TS2540: Cannot assign to 'name' because it is a read-only property.
注意如果 readonly 和其他访问修饰符同时存在的话，需要写在其后面。
class Animal {
// public readonly name;
public constructor(public readonly name) {
// this.name = name;
}
}
抽象类
abstract用于定义抽象类和其他的抽象方法
什么是抽象类？
首先，抽象类是不允许被实例化的：
abstract class Animal {
public name;
public constructor(name) {
this.name = name;
}
public abstract sayHi();
}
let a = new Animal('Jack');
// index.ts(9,11): error TS2511: Cannot create an instance of the abstract class 'Animal'.
上面的例子中，我们定义了一个抽象类 Animal，并且定义了一个抽象方法 sayHi。在实例化抽象类的时候报错了。
其次，抽象类中的抽象方法必须被子类实现
abstract class Animal {
public name;
public constructor(name) {
this.name = name;
}
public abstract sayHi();
}
class Cat extends Animal {
public eat() {
console.log(`${
this.name} is eating.`);
}
}
let cat = new Cat('Tom');
// index.ts(9,7): error TS2515: Non-abstract class 'Cat' does not implement inherited abstract member 'sayHi' from class 'Animal'.
上面的例子中，我们定义了一个类 Cat 继承了抽象类 Animal，但是没有实现抽象方法 sayHi，所以编译报错了
下面是一个正确使用抽象类的例子：
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');
上面的例子中，我们实现了抽象方法 sayHi，编译通过了。
需要注意的是，即使是抽象方法，TypeScript 的编译结果中，仍然会存在这个类，上面的代码的编译结果是：
var __extends =
(this && this.__extends) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() {
this.constructor = d;
}
d.prototype = b === null ? Object.create(b) : ((__.prototype = b.prototype), new __());
};
var Animal = (function () {
function Animal(name) {
this.name = name;
}
return Animal;
})();
var Cat = (function (_super) {
__extends(Cat, _super);
function Cat() {
_super.apply(this, arguments);
}
Cat.prototype.sayHi = function () {
console.log('Meow, My name is ' + this.name);
};
return Cat;
})(Animal);
var 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('Jack');
console.log(a.sayHi()); // My name is Jack
类与接口
之前学习过，接口（Interfaces）可以用于对「对象的形状（Shape）」进行描述。
这一章主要介绍接口的另一个用途，对类的一部分行为进行抽象。
类实现接口
实现（implements）是面向对象中的一个重要概念。一般来讲，一个类只能继承自另一个类，有时候不同类之间可以有一些共有的特性，这时候就可以把特性提取成接口（interfaces），用 implements 关键字来实现。这个特性大大提高了面向对象的灵活性。
举例来说，门是一个类，防盗门是门的子类。如果防盗门有一个报警器的功能，我们可以简单的给防盗门添加一个报警方法。这时候如果有另一个类，车，也有报警器的功能，就可以考虑把报警器提取出来，作为一个接口，防盗门和车都去实现它
interface Alarm{
alert():void
}
class Door {
}
class SecurityDoor extends Door implements Alarm{
alert(){
console.log('Car')
}
}
class Car implements Alarm {
alert(){
console.log('Alart')
}
}
一个类可以实现多个接口
interface Alarm {
alert():void
}
interface Light{
lightOut():void
lightOff():void
}
class Car implements Alarm,Light{
alert(){
console.log('Alert')
}
lightOut(){
console.log('LightOut')
}
lightOff(){
console.log("lightOff")
}
}
上例中，Car 实现了 Alarm 和 Light 接口，既能报警，也能开关车灯。
接口继承接口
接口与接口之间可以是继承关系：
interface Alarm {
alert():void
}
interface Right extends Alarm{
lightOn(): void;
lightOff(): void;
}
这很好理解，Right 继承了 Alarm，除了拥有 alert 方法之外，还拥有两个新方法 lightOn 和 lightOff。
接口继承类
常见的面向对象语言中，接口是不能继承类的，但是在 TypeScript 中却是可以的
class Point {
x: number;
y: number;
constructor(x: number, y: number) {
this.x = x;
this.y = y;
}
}
interface Point3d extends Point {
z: number;
}
let point3d: Point3d = {
x: 1, y: 2, z: 3};
为什么 TypeScript 会支持接口继承类呢？
实际上，当我们在声明 class Point 时，除了会创建一个名为 Point 的类之外，同时也创建了一个名为 Point 的类型（实例的类型）
所以我们既可以将 Point 当做一个类来用（使用 new Point 创建它的实例）
class Point {
x: number;
y: number;
constructor(x: number, y: number) {
this.x = x;
this.y = y;
}
}
const p = new Point(1, 2);
也可以将 Point 当做一个类型来用（使用 : Point 表示参数的类型）：
class Point {
x: number;
y: number;
constructor(x: number, y: number) {
this.x = x;
this.y = y;
}
}
function printPoint(p: Point) {
console.log(p.x, p.y);
}
printPoint(new Point(1, 2));
这个例子实际上可以等价于
class Point {
x: number;
y: number;
constructor(x: number, y: number) {
this.x = x;
this.y = y;
}
}
interface PointInstanceType {
x: number;
y: number;
}
function printPoint(p: PointInstanceType) {
console.log(p.x, p.y);
}
printPoint(new Point(1, 2));