TypeScript01-基础知识

基础类型

boolean 类型

let isDone: boolean = false;
// ES5：var isDone = false;

number 类型

let count: number = 10;
// ES5：var count = 10;

string 类型

let name: string = "semliker";
// ES5：var name = 'semlinker';

Symbol 类型

const sym = Symbol();
let obj = {[sym]: "semlinker",
};console.log(obj[sym]); // semlinker

Array 类型

let list: number[] = [1, 2, 3];
// ES5：var list = [1,2,3];let list: Array<number> = [1, 2, 3]; // Array<number>泛型语法
// ES5：var list = [1,2,3];

此外 TypeScript 还提供了 ReadonlyArray<T> 类型，它与 Array 相似，只是把所有可变方法去掉了，因此可以确保数组创建后再也不能被修改。

let a: number[] = [1, 2, 3, 4];
let ro: ReadonlyArray<number> = a;
ro[0] = 12; // error!
ro.push(5); // error!
ro.length = 100; // error!
a = ro; // error!

enum 类型

使用枚举我们可以定义一些带名字的常量。使用枚举可以清晰地表达意图或创建一组有区别的用例。 TypeScript 支持数字的和基于字符串的枚举。

数字枚举

//数字枚举
enum Direction {NORTH,SOUTH,EAST,WEST,
}
let dir: Direction = Direction.NORTH;

以上的枚举示例经编译后，对应的 ES5 代码如下：

"use strict";
var Direction;
(function (Direction) {Direction[(Direction["NORTH"] = 0)] = "NORTH";Direction[(Direction["SOUTH"] = 1)] = "SOUTH";Direction[(Direction["EAST"] = 2)] = "EAST";Direction[(Direction["WEST"] = 3)] = "WEST";
})(Direction || (Direction = {}));
var dir = Direction.NORTH;

默认情况下，NORTH 的初始值为 0，其余的成员会从 1 开始自动增长。换句话说，Direction.SOUTH 的值为 1，Direction.EAST 的值为 2，Direction.WEST 的值为 3。倘若将NORTH 换位NORTH=3，则Direction.EAST 的值为 4，Direction.WEST 的值为 5。

字符串枚举
在 TypeScript 2.4 版本，允许我们使用字符串枚举。在一个字符串枚举里，每个成员都必须用字符串字面量，或另外一个字符串枚举成员进行初始化。

enum Direction {NORTH = "NORTH",SOUTH = "SOUTH",EAST = "EAST",WEST = "WEST",
}

以上代码对应的 ES5 代码如下：

"use strict";
var Direction;
(function (Direction) {Direction["NORTH"] = "NORTH";Direction["SOUTH"] = "SOUTH";Direction["EAST"] = "EAST";Direction["WEST"] = "WEST";
})(Direction || (Direction = {}));

通过观察数字枚举和字符串枚举的编译结果，我们可以知道数字枚举除了支持从成员名称到成员值的普通映射之外，它还支持 从成员值到成员名称的反向映射：

enum Direction {NORTH,SOUTH,EAST,WEST,
}
let dirName = Direction[0]; // NORTH
let dirVal = Direction["NORTH"]; // 0

常量枚举
除了数字枚举和字符串枚举之外，还有一种特殊的枚举 —— 常量枚举。它是使用 const 关键字修饰的枚举，常量枚举会使用内联语法，不会为枚举类型编译生成任何 JavaScript。为了更好地理解这句话，我们来看一个具体的例子：

const enum Direction {NORTH,SOUTH,EAST,WEST,
}
let dir: Direction = Direction.NORTH;

以上代码对应的 ES5 代码如下：

"use strict";
var dir = 0 /* NORTH */;

异构枚举

enum Enum {A,B,C = "C",D = "D",E = 8,F,
}

以上代码对于的 ES5 代码如下：

"use strict";
var Enum;
(function (Enum) {Enum[Enum["A"] = 0] = "A";Enum[Enum["B"] = 1] = "B";Enum["C"] = "C";Enum["D"] = "D";Enum[Enum["E"] = 8] = "E";Enum[Enum["F"] = 9] = "F";
})(Enum || (Enum = {}));

通过观察上述生成的 ES5 代码，我们可以发现数字枚举相对字符串枚举多了 “反向映射”：

console.log(Enum.A) //输出：0
console.log(Enum[0]) // 输出：A

any 类型

在 TypeScript 中，任何类型都可以被归为 any 类型。这让 any 类型成为了类型系统的顶级类型（也被称作全局超级类型）。

let a: any = 666;
a = "Semlinker";
a = false;
a = 66
a = undefined
a = null
a = []
a = {}

any 类型本质上是类型系统的一个逃逸舱。作为开发者，这给了我们很大的自由：TypeScript 允许我们对 any 类型的值执行任何操作，而无需事先执行任何形式的检查。比如：

let value: any;
value.foo.bar; // OK
value.trim(); // OK
value(); // OK
new value(); // OK
value[0][1]; // OK

变量如果在声明的时候，未指定其类型，那么它会被识别为任意值类型，如下所示：

let something;
something = 'seven';
something = 7;
something.setName('Tom');
//上面这段代码等价于下面这段代码
let something: any;
something = 'seven';
something = 7;
something.setName('Tom');

在许多场景下，这太宽松了。使用 any 类型，可以很容易地编写类型正确但在运行时有问题的代码。如果我们使用 any 类型，就无法使用 TypeScript 提供的大量的保护机制。为了解决 any 带来的问题，TypeScript 3.0 引入了 unknown 类型。

unknown 类型

就像所有类型都可以赋值给 any，所有类型也都可以赋值给 unknown。这使得 unknown 成为 TypeScript 类型系统的另一种顶级类型（另一种是 any）。下面我们来看一下 unknown 类型的使用示例：

let value: unknown;
value = true; // OK
value = 42; // OK
value = "Hello World"; // OK
value = []; // OK
value = {}; // OK
value = Math.random; // OK
value = null; // OK
value = undefined; // OK
value = new TypeError(); // OK
value = Symbol("type"); // OK

任何值都可以赋值给unkonwn，但是unknown 类型只能被赋值给 any 类型和 unknown 类型本身。只有能够保存任意类型值的容器才能保存 unknown 类型的值。

let value: unknown;
let value1: unknown = value; // OK
let value2: any = value; // OK
let value3: boolean = value; // Error
let value4: number = value; // Error
let value5: string = value; // Error
let value6: object = value; // Error
let value7: any[] = value; // Error
let value8: Function = value; // Error

现在让我们看看当我们尝试对类型为 unknown 的值执行操作时会发生什么。以下是我们在之前 any 章节看过的相同操作：

let value: unknown;value.foo.bar; // Error
value.trim(); // Error
value(); // Error
new value(); // Error
value[0][1]; // Error

将 value 变量类型设置为 unknown 后，这些操作都不再被认为是类型正确的。通过将 any 类型改变为 unknown 类型，我们已将允许所有更改的默认设置，更改为禁止任何更改。

tuple 类型

数组一般由同种类型的值组成，但有时我们需要在单个变量中存储不同类型的值，这时候我们就可以使用元组。在 JavaScript 中是没有元组的，元组是 TypeScript 中特有的类型。

let tupleType: [string, boolean];
tupleType = ["semlinker", true];
console.log(tupleType[0]); // semlinker
console.log(tupleType[1]); // true

当元组类型未按照指定顺序类型时，编译器会提示以下错误信息：

tupleType = [true, "semlinker"];
[0]: Type 'true' is not assignable to type 'string'.
[1]: Type 'string' is not assignable to type 'boolean'.

在元组初始化的时候，我们还必须提供每个属性的值，不能缺少，不然也会出现错误，
元组类型只能表示一个已知元素数量和类型的数组，长度已指定，越界访问会提示错误。如果一个数组中可能有多种类型，数量和类型都不确定，那就直接any[]。下面是元组缺少的情况：

tupleType = ["semlinker"];
Property '1' is missing in type '[string]' but required in type '[string, boolean]'.

在解构赋值时，如果解构数组元素的个数是不能超过元组中元素的个数，否则也会出现错误，比如：

let employee: [number, string] = [1, "Semlinker"];
let [id, username, age] = employee;

在定义元组类型时，我们也可以通过 ? 号来声明元组类型的可选元素，下面我们定义了一个名为 optionalTuple 的变量，该变量的类型要求包含一个必须的字符串属性和一个可选布尔属性。具体的示例如下：

let optionalTuple: [string, boolean?];
optionalTuple = ["Semlinker", true];
console.log(`optionalTuple : ${optionalTuple}`);
optionalTuple = ["Kakuqo"];
console.log(`optionalTuple : ${optionalTuple}`);

这样做的好处就是具有一定的拓展性：

type Point = [number, number?, number?];
const x: Point = [10]; // 一维坐标点
const xy: Point = [10, 20]; // 二维坐标点
const xyz: Point = [10, 20, 10]; // 三维坐标点
console.log(x.length); // 1
console.log(xy.length); // 2
console.log(xyz.length); // 3

对比上面的这些元组来说位数是固定的(最大位数)，下面我们可以通过可变参数来实现不固定的元组。

type RestTupleType = [number, ...string[]];
let restTuple: RestTupleType = [666, "Semlinker", "Kakuqo", "Lolo"];
console.log(restTuple[0]);
console.log(restTuple[1]);

元组类型里最后一个元素可以是剩余元素，形式为 ...X，这里 X 是数组类型。剩余元素代表元组类型是开放的，可以有零个或多个额外的元素。例如，[number, …string[]] 表示带有一个 number 元素和任意数量string 类型元素的元组类型，上述例子就是如此。

void 类型

某种程度上来说，void 类型像是与 any 类型相反，它表示没有任何类型。当一个函数没有返回值时，你通常会见到其返回值类型是 void：

// 声明函数返回值为void
function warnUser(): void {console.log("This is my warning message");
}

以上代码编译生成的 ES5 代码如下：

"use strict";
function warnUser() {console.log("This is my warning message");
}

需要注意的是，声明一个 void 类型的变量没有什么作用，因为在严格模式下，它的值只能为 undefined

let unusable: void = undefined;

null 和 undefined 类型

TypeScript 里，undefined 和 null 两者有各自的类型分别为 undefined 和 null。

let u: undefined = undefined;
let n: null = null;

object, Object 和 {} 类型

object： object 类型用于表示所有的非原始类型，即我们不能把 number、string、boolean、symbol等原始类型赋值给 object。在严格模式下，null 和 undefined 类型也不能赋给 object。

// node_modules/typescript/lib/lib.es5.d.ts
interface ObjectConstructor {create(o: object | null): any;// ...
}
const proto = {};
Object.create(proto);     // OK
Object.create(null);      // OK
Object.create(undefined); // Error
Object.create(1337);      // Error
Object.create(true);      // Error
Object.create("oops");    // Error

let object: object;
object = 1; // 报错
object = "a"; // 报错
object = true; // 报错
object = null; // 报错
object = undefined; // 报错
object = {}; // 编译正确

Object：Object 代表所有拥有 toString、hasOwnProperty 方法的类型。所以所有原始类型、非原始类型都可以赋给 Object，严格模式下 null 和 undefined 不可以。

// Object 接口定义了 Object.prototype 原型对象上的属性；
// node_modules/typescript/lib/lib.es5.d.ts
interface Object {constructor: Function;toString(): string;toLocaleString(): string;valueOf(): Object;hasOwnProperty(v: PropertyKey): boolean;isPrototypeOf(v: Object): boolean;propertyIsEnumerable(v: PropertyKey): boolean;
}// ObjectConstructor 接口定义了 Object 类的属性。
// node_modules/typescript/lib/lib.es5.d.ts
interface ObjectConstructor {/** Invocation via `new` */new(value?: any): Object;/** Invocation via function calls */(value?: any): any;readonly prototype: Object;getPrototypeOf(o: any): any;// ···
}
declare var Object: ObjectConstructor;

{}：{} 空对象类型和大 Object 一样也是表示原始类型和非原始类型的集合。
其描述了一个没有成员的对象。当你试图访问这样一个对象的任意属性时，TypeScript 会产生一个编译时错误。但是，你仍然可以使用在 Object 类型上定义的所有属性和方法，这些属性和方法可通过 JavaScript 的原型链隐式地使用：

// Type {}
const obj = {};//错误
obj.prop = "semlinker";
// Error: Property 'prop' does not exist on type '{}'.// "[object Object]"
obj.toString();//正确

never 类型

never 类型表示的是那些永不存在的值的类型。例如，never 类型是那些总是会抛出异常或根本就不会有返回值的函数表达式或箭头函数表达式的返回值类型。

// 返回never的函数必须存在无法达到的终点
function error(message: string): never {throw new Error(message);
}
function infiniteLoop(): never {while (true) {}
}

在 TypeScript 中，可以利用 never 类型的特性来实现全面性检查，具体示例如下：

type Foo = string | number;
function controlFlowAnalysisWithNever(foo: Foo) {if (typeof foo === "string") {// 这里 foo 被收窄为 string 类型} else if (typeof foo === "number") {// 这里 foo 被收窄为 number 类型} else {// foo 在这里是 neverconst check: never = foo;}
}

注意在 else 分支里面，我们把收窄为 never 的 foo 赋值给一个显示声明的 never 变量。如果一切逻辑正确，那么这里应该能够编译通过。但是假如后来有一天你的同事修改了 Foo 的类型：

type Foo = string | number | boolean;

然而他忘记同时修改 controlFlowAnalysisWithNever 方法中的控制流程，这时候 else 分支的 foo 类型会被收窄为 boolean 类型，导致无法赋值给 never 类型，这时就会产生一个编译错误。通过这个方式，我们可以确保 controlFlowAnalysisWithNever 方法总是穷尽了 Foo 的所有可能类型。通过这个示例，我们可以知道使用 never 避免出现新增了联合类型没有对应的实现。

函数

TypeScript	JavaScript
含有类型	无类型
箭头函数	箭头函数（ES2015）
函数类型	无函数类型
必填和可选参数	所有参数都是可选的
默认参数	默认参数
剩余参数	剩余参数
函数重载	无函数重载

函数类型包含两部分：参数类型和返回值类型。当写出完整函数类型的时候，这两部分都是需要的。

函数声明

function add(x: number, y: number): number {return x + y;
}

给每个参数添加类型之后，可以不用给函数本身添加返回值类型，因为TypeScript能根据返回语句自动推断出返回值类型

函数表达式

const add = function(x: number, y: number): number {return x + y;
}

可选参数函数

可选参数必须跟在必须参数后面。

function add(x: number, y?: number): number {return y ? x + y : x;
}
let res = add(1)//1
let res = add(1,)//1
let res = add(1,undefined)//1
let res = add(1,2)//3

默认参数函数

function add(x: number, y: number = 0): number {return x + y;
}
let res = add(1)//1
let res = add(1,)//1
let res = add(1,undefined)//1
let res = add(1,2)//3

可变参数函数

function add(star:number,...others: number[]): number {let sum = 0;for (let i = 0; i < others.length; i++) {sum += others[i];}return sum + star;
}
let res = add(1,1,2,3,4)
console.log(res)//11

函数重载

由于 JavaScript 是一个动态语言，我们通常会使用不同类型的参数来调用同一个函数，该函数会根据不同的参数而返回不同的类型的调用结果：

function add (x, y) {return x + y;
}
add(1, 2);   // 3
add("1", "2");  // "12"

以上代码在JS环境中运行是没有问题的，但是如果在TypeScript环境下且TypeScript编译器开启noImplicitAny(将TypeScript从可选类型语言转换为强制类型检验语言)配置项时，以上代码会提示以下错误信息：

Parameter 'x' implicitly has an 'any' type.
Parameter 'y' implicitly has an 'any' type.

该信息告诉我们参数 x 和参数 y 隐式具有 any 类型。为了解决这个问题，我们可以为参数设置一个类型。因为我们希望 add 函数同时支持 string 和 number 类型，因此我们可以定义一个 string | number 联合类型

function add (x: number | string, y: number | string) {if (typeof x === 'string' || typeof y === 'string') {return x.toString() + y.toString();}return x + y;
}

设置了联合类型后，之前错误提示信息就消失了，接着下一步：

let result = add('hearts', 'spades');
result.split(' ');

我们想当然的以为result类型为string，然后就可以正常使用字符串对象上的split方法，结果又出现了新问题，提示number类型的对象上并不存在split属性。

Property 'split' does not exist on type 'string | number'.  
Property 'split' does not exist on type 'number'.

为了解决这个问题可以使用函数重载。可以为同一个函数提供多个函数类型定义来进行函数重载（函数名称相同，参数数量或类型不同，或者参数数量相同同时参数顺序不同）。

type Types = number | string;
// 重载签名
function add(x: number, y: number): number;
function add(x: string, y: string): string;
function add(x: string, y: number): string;
function add(x: number, y: string): string;
function add(x: Types, y: Types) {if (typeof x === 'string' || typeof y === 'string') {return x.toString() + y.toString();}return x + y;
}
const result = add('hearts', ' spades');
result.split(' ');

函数重载真正执行的是同名函数最后定义的函数体在最后一个函数体定义之前全都属于函数类型定义不能写具体的函数实现方法只能定义类型
具体示例原理参考

特殊类型

字面量类型

在 TypeScript 中，字面量不仅可以表示值，还可以表示类型，即所谓的字面量类型。目前，TypeScript 支持 3 种字面量类型：字符串字面量类型、数字字面量类型、布尔字面量类型，对应的字符串字面量、数字字面量、布尔字面量分别拥有与其值一样的字面量类型，具体示例如下：

{let specifiedStr: 'this is string' = 'this is string';let specifiedNum: 1 = 1;let specifiedBoolean: true = true;
}

比如 ‘this is string’ （这里表示一个字符串字面量类型）类型是 string 类型（确切地说是 string 类型的子类型），而 string 类型不一定是 ‘this is string’（这里表示一个字符串字面量类型）类型，如下具体示例：

{let specifiedStr: 'this is string' = 'this is string';let str: string = 'any string';specifiedStr = str; // ts(2322) 类型 '"string"' 不能赋值给类型 'this is string'str = specifiedStr; // ok 
}

比如说我们用“马”比喻 string 类型，即“黑马”代指 ‘this is string’ 类型，“黑马”肯定是“马”，但“马”不一定是“黑马”，它可能还是“白马”“灰马”。因此，‘this is string’ 字面量类型可以给 string 类型赋值，但是 string 类型不能给 ‘this is string’ 字面量类型赋值，这个比喻同样适合于形容数字、布尔等其他字面量和它们父类的关系。

字符串字面量类型

一般来说，我们可以使用一个字符串字面量类型作为变量的类型，如下代码所示：

let hello: 'hello' = 'hello';
hello = 'hi'; // ts(2322) Type '"hi"' is not assignable to type '"hello"'

实际上，定义单个的字面量类型并没有太大的用处，它真正的应用场景是可以把多个字面量类型组合成一个联合类型（后面会讲解），用来描述拥有明确成员的实用的集合。如下代码所示，我们使用字面量联合类型描述了一个明确、可 ‘up’ 可 ‘down’ 的集合，这样就能清楚地知道需要的数据结构了。

type Direction = 'up' | 'down';function move(dir: Direction) {// ...
}
move('up'); // ok
move('right'); // ts(2345) Argument of type '"right"' is not assignable to parameter of type 'Direction'

通过使用字面量类型组合的联合类型，我们可以限制函数的参数为指定的字面量类型集合，然后编译器会检查参数是否是指定的字面量类型集合里的成员。
因此，相较于使用 string 类型，使用字面量类型（组合的联合类型）可以将函数的参数限定为更具体的类型。这不仅提升了程序的可读性，还保证了函数的参数类型，可谓一举两得。

数字字面量类型
数字字面量类型和布尔字面量类型的使用与字符串字面量类型的使用类似，我们可以使用字面量组合的联合类型将函数的参数限定为更具体的类型，比如声明如下所示的一个类型 Config：

interface Config {margin: 0 | 2 | 4;
}

在上述代码中，我们限定了margin 属性为数字字面量类型 0 | 2 | 4。若我们指定其他值则会报错，如下所示：
在这里插入图片描述

布尔字面量类型

interface Config {isEnable:  true | false;
}

在上述代码中，我们限定了isEnable 属性为布尔字面量类型 true | false（布尔字面量只包含 true 和 false，true | false 的组合跟直接使用 boolean 没有区别）。

联合类型

联合类型表示取值可以为多种类型中的一种，使用 | 分隔每个类型。

let myFavoriteNumber: string | number;
myFavoriteNumber = 'seven'; // OK
myFavoriteNumber = 7; // OK

联合类型通常与 null 或 undefined 一起使用：

const sayHello = (name: string | undefined) => {/* ... */
};
sayHello("semlinker"); 
sayHello(undefined);

此外，对于联合类型来说，你可能会遇到以下的用法：

let num: 1 | 2 = 1;
type EventNames = 'click' | 'scroll' | 'mousemove';

以上示例中的 1、2 或 ‘click’ 被称为字面量类型，用来约束取值只能是某几个值中的一个。

类型别名

类型别名用来给一个类型起个新名字。类型别名常用于联合类型。

type Message = string | string[];
let greet = (message: Message) => {// ...
};

注意：类型别名，诚如其名，即我们仅仅是给类型取了一个新的名字，并不是创建了一个新的类型。

交叉类型

交叉类型是将多个类型合并为一个类型。这让我们可以把现有的多种类型叠加到一起成为一种类型，它包含了所需的所有类型的特性，使用&定义交叉类型。

{type Useless = string & number;
}

很显然，如果我们仅仅把原始类型、字面量类型、函数类型等原子类型合并成交叉类型，是没有任何用处的，因为任何类型都不能满足同时属于多种原子类型，比如既是 string 类型又是 number 类型。因此，在上述的代码中，类型别名 Useless 的类型就是个 never。

交叉类型真正的用武之地就是将多个接口类型合并成一个类型，从而实现等同接口继承的效果，也就是所谓的合并接口类型。在下面例子中，我们通过交叉类型，使得 IntersectionType 同时拥有了 id、name、age 所有属性，这里我们可以试着将合并接口类型理解为求并集。相关代码如下所示：

type IntersectionType = { id: number; name: string; } & { age: number };const mixed: IntersectionType = {id: 1,name: 'name',age: 18}

如果同名属性的类型不兼容，比如上面示例中两个接口类型同名的 name 属性类型一个是 number，另一个是 string，合并后，name 属性的类型就是 number 和 string 两个原子类型的交叉类型，即 never，如下代码所示：

  type IntersectionTypeConfict = { id: number; name: string; } & { age: number; name: number; };const mixedConflict: IntersectionTypeConfict = {id: 1,name: 2, // ts(2322) 错误，'number' 类型不能赋给 'never' 类型age: 2};

如果我们不设置 name 属性，又会提示一个缺少必选的 name 属性的错误。

如果同名属性的类型兼容，比如一个是 number，另一个是 number 的子类型、数字字面量类型，合并后 name 属性的类型就是两者中的子类型。
如下所示示例中 name 属性的类型就是数字字面量类型 2，因此，我们不能把任何非 2 之外的值赋予 name 属性。

  type IntersectionTypeConfict = { id: number; name: 2; } & { age: number; name: number; };let mixedConflict: IntersectionTypeConfict = {id: 1,name: 2, // okage: 2};mixedConflict = {id: 1,name: 22, // '22' 类型不能赋给 '2' 类型age: 2};

那么如果同名属性是非基本数据类型的话，又会是什么情形。我们来看个具体的例子：

interface A {x:{d:true},
}
interface B {x:{e:string},
}
interface C {x:{f:number},
}
type ABC = A & B & C
let abc:ABC = {x:{d:true,e:'',f:666}
}

以上代码成功运行后，会输出以下结果：
在这里插入图片描述
由上图可知，在混入多个类型时，若存在相同的成员，且成员类型为非基本数据类型，那么是可以成功合并。

let和const修饰的区别

我们先来看一个 const 示例，我们将 const 定义为一个不可变更的常量，在缺省类型注解的情况下，TypeScript 推断出它的类型直接由赋值字面量的类型决定，这也是一种比较合理的设计。如下代码所示：

{const str = 'this is string'; // str: 'this is string'const num = 1; // num: 1const bool = true; // bool: true
}

接下来我们看看如下所示的 let 示例，缺省显式类型注解的可变更的变量的类型转换为了赋值字面量类型的父类型，比如 str 的类型是 ‘this is string’ 类型（这里表示一个字符串字面量类型）的父类型 string，num 的类型是 1 类型的父类型 number。如下代码所示：

{let str = 'this is string'; // str: stringlet num = 1; // num: numberlet bool = true; // bool: boolean
}

这种设计符合编程预期，意味着我们可以分别赋予 str 和 num 任意值（只要类型是 string 和 number 的子集的变量）
str = ‘any string’;
num = 2;
bool = false;

我们将 TypeScript 的字面量子类型转换为父类型的这种设计称之为 “literal widening”，也就是字面量类型的拓宽，比如上面示例中提到的字符串字面量类型转换成 string 类型。

类型拓宽

所有通过 let 或 var 定义的变量、函数的形参、对象的非只读属性，如果满足指定了初始值且未显式添加类型注解的条件，那么它们推断出来的类型就是指定的初始值字面量类型拓宽后的类型，这就是字面量类型拓宽。下面我们通过字符串字面量的示例来理解一下字面量类型拓宽：

  let str = 'this is string'; // 类型是 stringlet strFun = (str = 'this is string') => str; // 类型是 (str?: string) => string;const specifiedStr = 'this is string'; // 类型是 'this is string'let str2 = specifiedStr; // 类型是 'string'let strFun2 = (str = specifiedStr) => str; // 类型是 (str?: string) => string;

因为第 1~2 行满足了 let、形参且未显式声明类型注解的条件，所以变量、形参的类型拓宽为 string（形参类型确切地讲是 string | undefined）。
因为第 3 行的常量不可变更，类型没有拓宽，所以 specifiedStr 的类型是 ‘this is string’ 字面量类型。
第 4~5 行，因为赋予的值 specifiedStr 的类型是字面量类型，且没有显式类型注解，所以变量、形参的类型也被拓宽了。其实，这样的设计符合实际编程诉求。我们设想一下，如果 str2 的类型被推断为 ‘this is string’，它将不可变更，因为赋予任何其他的字符串类型的值都会提示类型错误。
基于字面量类型拓宽的条件，我们可以通过如下所示代码添加显示类型注解控制类型拓宽行为。

{const specifiedStr: 'this is string' = 'this is string'; // 类型是 '"this is string"'let str2 = specifiedStr; // 即便使用 let 定义，类型是 'this is string'
}

原文出处

类型缩小

在 TypeScript 中，我们可以通过某些操作将变量的类型由一个较为宽泛的集合缩小到相对较小、较明确的集合，这就是 “Type Narrowing”。比如，我们可以使用类型守卫将函数参数的类型从 any 缩小到明确的类型，具体示例如下：

{let func = (anything: any) => {if (typeof anything === 'string') {return anything; // 类型是 string } else if (typeof anything === 'number') {return anything; // 类型是 number}return null;};
}

原文出处

类型推断

如果没有明确的指定类型，那么 TypeScript 会依照类型推论的规则推断出一个类型。

let x = 1;
x = true; // 报错// 这段代码等价于
let x: number = 1;
x = true; // 报错

通过上述示例我们可以看出，我们没有给 x 指定明确类型的时候，typescript 会推断出 x 的类型是 number。而如果定义的时候没有赋值，不管之后有没有赋值，都会被推断成 any 类型而完全不被类型检查：

let x;
x = 1; // 编译正确
x = true; // 编译正确

类型断言

类型断言的意义就等同于你在告诉程序，你很清楚自己在做什么，此时程序自然就不会再进行额外的属性检查了。

类型断言

TypeScript 类型检测，我们会遇到一下问题：

const arrayNumber: number[] = [1, 2, 3, 4];
const greaterThan2: number = arrayNumber.find(num => num > 2); // 提示 ts(2322)

其中，greaterThan2 一定是一个数字（确切地讲是 3），因为 arrayNumber 中明显有大于 2 的成员，但静态类型对运行时的逻辑无能为力。在 TypeScript 看来，greaterThan2 的类型既可能是数字，也可能是 undefined，所以上面的示例中提示了一个 ts(2322) 错误，此时我们不能把类型 undefined 分配给类型 number。此时我们可以使用类型断言，告知TypeScript按照我们的方式进行类型检查。

const arrayNumber: number[] = [1, 2, 3, 4];
const greaterThan2: number = arrayNumber.find(num => num > 2) as number;

常见语法如下所示：

// 尖括号语法
let someValue: any = “this is a string”;
let strLength: number = (someValue).length;
// as 语法
let someValue: any = “this is a string”;
let strLength: number = (someValue as string).length;

以上两种方式虽然没有任何区别，但是尖括号格式会与react中JSX产生语法冲突，因此我们更推荐使用 as 语法。

空断言

在上下文中当类型检查器无法断定类型时，一个新的后缀表达式操作符 ! 可以用于断言操作对象是非 null 和非 undefined 类型。具体而言，x! 将从 x 值域中排除 null 和 undefined。

let mayNullOrUndefinedOrString: null | undefined | string;
mayNullOrUndefinedOrString!.toString(); // ok
mayNullOrUndefinedOrString.toString(); // ts(2531)

type NumGenerator = () => number;
function myFunc(numGenerator: NumGenerator | undefined) {// Object is possibly 'undefined'.(2532)// Cannot invoke an object which is possibly 'undefined'.(2722)const num1 = numGenerator(); // Errorconst num2 = numGenerator!(); //OK
}

确定赋值断言

允许在实例属性和变量声明后面放置一个 ! 号，从而告诉 TypeScript 该属性会被明确地赋值。为了更好地理解它的作用，我们来看个具体的例子：

let x: number;
initialize();
// Variable 'x' is used before being assigned.(2454)
console.log(2 * x); // Error
function initialize() {x = 10;
}
//TypeScript 编译器就会知道该属性会被明确地赋值。
let x!: number;

TypeScript 接口

在面向对象语言中，接口（Interfaces）是一个很重要的概念，它是对行为的抽象，而具体如何行动需要由类（classes）去实现（implement）。
TypeScript 中的接口是一个非常灵活的概念，除了可用于[对类的一部分行为进行抽象]以外，也常用于对「对象的形状（Shape）」进行描述。

接口声明

interface Person {name: string;age: number;
}
let tom: Person = {name: 'Tom',age: 25
};

上面的例子中，我们定义了一个接口 Person，接着定义了一个变量 tom，它的类型是 Person。这样，我们就约束了 tom 的形状必须和接口 Person 一致。若定义的变量比接口少(多)了一些属性是不允许的：

let tom: Person = {name: 'Tom'
};//错误
let tom: Person = {name: 'Tom',age: 25,gender: 'male'
};//错误

可选|只读属性

interface Person {readonly name: string;//只读age?: number;//可选
}

只读属性用于限制只能在对象刚刚创建的时候修改其值。

interface Person{readonly name:string;age?:number;
}
let me:Person = {name:'a',age:2}
console.log(me)
me.name = 'c';//错误
me.age = 3;

在这里插入图片描述

任意属性(索引签名)

有时候我们希望一个接口中除了包含必选和可选属性之外，还允许有其他的任意属性，这时我们可以使用索引签名的形式来满足上述要求。

interface Person {name: string;age?: number;[propName: string]: any; //  propName字段必须是 string类型 or number类型。 值是any类型，也就是任意的
}const p1:Person = { name: "张麻子" };
const p2:Person = { name: "树哥", age: 28 };
const p3:Person = { name: "汤师爷", sex: 1 }

需要注意的是，propName字段一旦定义了任意属性，那么确定属性和可选属性的类型都必须是它的类型的子集。

interface Person {name: string;age?: number;[propName: string]: string;
}let tom: Person = {name: 'Tom',age: 25,gender: 'male'
};

上例中，任意属性的值允许是 string，但是可选属性 age 的值却是 number，number 不是 string 的子属性，所以报错了。
在这里插入图片描述
若不能使用any来指定类型，我们可以使用联合类型来实现。

interface Person {name: string;age?: number;[propName: string]: string | number | undefined;//支持string/number/undefined
}
let tom: Person = {name: 'Tom',age: 25,gender: 'male'
};

鸭式辨型法

所谓的鸭式辨型法就是像鸭子一样走路并且嘎嘎叫的就叫鸭子，即具有鸭子特征的认为它就是鸭子，也就是通过制定规则来判定对象是否实现这个接口。

interface LabeledValue {label: string;
}
function printLabel(labeledObj: LabeledValue) {console.log(labeledObj.label);
}
//方式1：
let myObj = { size: 10, label: "Size 10 Object" };
printLabel(myObj); // OK
//方式2：
printLabel({ size: 10, label: "Size 10 Object" }); // Error

上面代码，在参数里写对象就相当于是直接给labeledObj赋值，这个对象有严格的类型定义，所以不能多参或少参。而当你在外面将该对象用另一个变量myObj接收，myObj不会经过额外属性检查，但会根据类型推论，认为myObj: { size: number; label: string } = { size: 10, label: "Size 10 Object" };，然后将这个myObj再赋值给labeledObj，此时根据类型的兼容性，两种类型对象，参照鸭式辨型法，因为都具有label属性，所以被认定为两个相同，故而可以用此法来绕开多余的类型检查。

额外属性检查

interface Square {color: string,area: number
}
interface SquareConfig {color?: string,width?: number
}
function createSquare(config: SquareConfig): Square {let newSquare = { color: "white", area: 100 };if (config.color) {newSquare.color = config.color;}if (config.width) {newSquare.area = config.width * config.width;}return newSquare;
}
createSquare({ color: "black",  opacity: 0.5 });

虽然SquareConfig里的属性都是可选属性（Optional Properties），但这只意味着接口实例里可以没有这个的属性，并不意味着可以多出其他的属性。检查是否有不在接口定义中的属性，就是额外的属性检查。

如何避免额外属性检查：

鸭式辨型法
类型断言
索引签名

原文出处

type与interface区别

实际上，在大多数的情况下使用接口类型和类型别名的效果等价，但是在某些特定的场景下这两者还是存在很大区别。

TypeScript 的核心原则之一是对值所具有的结构进行类型检查。而接口的作用就是为这些类型命名和为你的代码或第三方代码定义数据模型。

type(类型别名)会给一个类型起个新名字。 type 有时和 interface 很像，但是可以作用于原始值（基本类型），联合类型，元组以及其它任何你需要手写的类型。起别名不会新建一个类型 - 它创建了一个新名字来引用那个类型。给基本类型起别名通常没什么用，尽管可以做为文档的一种形式使用。

Objects / Functions

两者都可以用来描述对象或函数的类型，但是语法不同。

interface Point {x: number;y: number;
}
interface SetPoint {(x: number, y: number): void;
}

type Point = {x: number;y: number;
};
type SetPoint = (x: number, y: number) => void;

Other Types

与接口不同，类型别名还可以用于其他类型，如基本类型（原始值）、联合类型、元组。

// primitive
type Name = string;// object
type PartialPointX = { x: number; };
type PartialPointY = { y: number; };// union
type PartialPoint = PartialPointX | PartialPointY;// tuple
type Data = [number, string];// dom
let div = document.createElement('div');
type B = typeof div;

可重复定义性

接口可以定义多次,类型别名不可以。多次定义的属性会被合并。

interface Point { x: number; }
interface Point { y: number; }
const point: Point = { x: 1, y: 2 };

可扩展性

两者的扩展方式不同，但并不互斥。接口可以扩展类型别名，同理，类型别名也可以扩展接口。接口的扩展就是继承，通过 extends 来实现。类型别名的扩展就是交叉类型，通过 & 来实现。

接口扩展接口

interface PointX {x: number
}interface Point extends PointX {y: number
}

类型别名扩展类型别名

type PointX = {x: number
}
type Point = PointX & {y: number
}

接口扩展类型别名

type PointX = {x: number
}
interface Point extends PointX {y: number
}

类型别名扩展接口

interface PointX {x: number
}
type Point = PointX & {y: number
}

TypeScript 类

在面向对象语言中，类是一种面向对象计算机编程语言的构造，是创建对象的蓝图，描述了所创建的对象共同的属性和方法。

属性和方法

在 TypeScript 中，我们可以通过 Class 关键字来定义一个类：

class Greeter {// 静态属性static cname: string = "Greeter";// 成员属性greeting: string;// 构造函数 - 执行初始化操作constructor(message: string) {this.greeting = message;}// 静态方法static getClassName() {return "Class name is Greeter";}// 成员方法greet() {return "Hello, " + this.greeting;}
}
let greeter = new Greeter("world");

那么成员属性与静态属性，成员方法与静态方法有什么区别呢？这里无需过多解释，我们直接看一下编译生成的 ES5 代码：

"use strict";
var Greeter = /** @class */ (function () {// 构造函数 - 执行初始化操作function Greeter(message) {this.greeting = message;}// 静态方法Greeter.getClassName = function () {return "Class name is Greeter";};// 成员方法Greeter.prototype.greet = function () {return "Hello, " + this.greeting;};// 静态属性Greeter.cname = "Greeter";return Greeter;
}());
var greeter = new Greeter("world");

ECMAScript 私有字段

在 TypeScript 3.8 版本就开始支持ECMAScript 私有字段，使用方式如下：

class Person {#name: string;constructor(name: string) {this.#name = name;}greet() {console.log(`Hello, my name is ${this.#name}!`);}
}let semlinker = new Person("Semlinker");semlinker.#name;
//     ~~~~~
// Property '#name' is not accessible outside class 'Person'
// because it has a private identifier.

与常规属性（甚至使用 private 修饰符声明的属性）不同，私有字段要牢记以下规则：

私有字段以 # 字符开头，有时我们称之为私有名称；
每个私有字段名称都唯一地限定于其包含的类；
不能在私有字段上使用 TypeScript 可访问性修饰符（如 public 或 private）；
私有字段不能在包含的类之外访问，甚至不能被检测到。

访问器

在 TypeScript 中，我们可以通过 getter 和 setter 方法来实现数据的封装和有效性校验，防止出现异常数据。

let passcode = "Hello TypeScript";class Employee {private _fullName: string;get fullName(): string {return this._fullName;}set fullName(newName: string) {if (passcode && passcode == "Hello TypeScript") {this._fullName = newName;} else {console.log("Error: Unauthorized update of employee!");}}
}let employee = new Employee();
employee.fullName = "Semlinker";
if (employee.fullName) {console.log(employee.fullName);
}

继承 extends

继承（Inheritance）是一种联结类与类的层次模型。指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力，继承是类与类或者接口与接口之间最常见的关系。
继承是一种 is-a 关系：
在这里插入图片描述
在 TypeScript 中，我们可以通过 extends 关键字来实现继承：

class Animal {name: string;constructor(theName: string) {this.name = theName;}move(distanceInMeters: number = 0) {console.log(`${this.name} moved ${distanceInMeters}m.`);}
}class Snake extends Animal {constructor(name: string) {super(name); // 调用父类的构造函数}move(distanceInMeters = 5) {console.log("Slithering...");super.move(distanceInMeters);}
}let sam = new Snake("Sammy the Python");
sam.move();

抽象类

使用 abstract 关键字声明的类，我们称之为抽象类。抽象类不能被实例化，因为它里面包含一个或多个抽象方法。所谓的抽象方法，是指不包含具体实现的方法：

在abstract class Person {constructor(public name: string){}abstract say(words: string) :void;
}// Cannot create an instance of an abstract class.(2511)
const lolo = new Person(); // Error

抽象类不能被直接实例化，我们只能实例化实现了所有抽象方法的子类。具体如下所示：

abstract class Person {constructor(public name: string){}// 抽象方法abstract say(words: string) :void;
}class Developer extends Person {constructor(name: string) {super(name);}say(words: string): void {console.log(`${this.name} says ${words}`);}
}const lolo = new Developer("lolo");
lolo.say("I love ts!"); // lolo says I love ts!

方法重载

在前面的章节，我们已经介绍了函数重载。对于类的方法来说，它也支持重载。比如，在以下示例中我们重载了 ProductService 类的 getProducts 成员方法：

class ProductService {getProducts(): void;getProducts(id: number): void;getProducts(id?: number) {if(typeof id === 'number') {console.log(`获取id为 ${id} 的产品信息`);} else {console.log(`获取所有的产品信息`);}  }
}const productService = new ProductService();
productService.getProducts(666); // 获取id为 666 的产品信息
productService.getProducts(); // 获取所有的产品信息

TypeScript 泛型

假如让你实现一个函数 identity，函数的参数可以是任何值，返回值就是将参数原样返回，并且其只能接受一个参数，你会怎么做？
你会觉得这很简单，顺手就写出这样的代码：

const identity = (arg) => arg;

由于其可以接受任意值，也就是说你的函数的入参和返回值都应该可以是任意类型。现在让我们给代码增加类型声明：

type idBoolean = (arg: boolean) => boolean;
type idNumber = (arg: number) => number;
type idString = (arg: string) => string;

一个笨的方法就像上面那样，也就是说 JS 提供多少种类型，就需要复制多少份代码，然后改下类型签名，这样做缺乏拓展性。还有一种方式是使用 any 这种“万能语法”，比如下面这个例子：

identity("string").length; // ok
identity("string").toFixed(2); // ok
identity(null).toString(); // ok

如果你使用 any 的话，怎么写都是 ok 的，这就丧失了类型检查的效果。实际上我知道我传给你的是 string，返回来的也一定是 string，而 string 上没有 toFixed 方法，因此需要报错才是我想要的。也就是说我真正想要的效果是：当我用到id的时候，你根据我传给你的类型进行推导。比如我传入的是 string，但是使用了 number 上的方法，你就应该报错。

泛型介绍

为了解决上面的这些问题，我们使用泛型对上面的代码进行重构。和我们的定义不同，这里用了一个 类型 T，这个 T 是一个抽象类型，只有在调用的时候才确定它的值，这就不用我们复制粘贴无数份代码了。

function identity<T>(arg: T): T {return arg;
}

其中 T 代表 Type，在定义泛型时通常用作第一个类型变量名称。但实际上 T 可以用任何有效名称代替。除了 T 之外，以下是常见泛型变量代表的意思：

K（Key）：表示对象中的键类型。
V（Value）：表示对象中的值类型。
E（Element）：表示元素类型。

其实并不是只能定义一个类型变量，我们可以引入希望定义的任何数量的类型变量。比如我们引入一个新的类型变量 U，用于扩展我们定义的 identity 函数：

function identity <T, U>(value: T, message: U) : T {console.log(message);return value;
}
console.log(identity<Number, string>(68, "Semlinker"));

在这里插入图片描述
除了为类型变量显式设定值之外，一种更常见的做法是使编译器自动选择这些类型，从而使代码更简洁。我们可以完全省略尖括号，比如：

function identity <T, U>(value: T, message: U) : T {console.log(message);return value;
}
console.log(identity(68, "Semlinker"));

对于上述代码，编译器足够聪明，能够知道我们的参数类型，并将它们赋值给 T 和 U，而不需要开发人员显式指定它们。

泛型约束

假如我想打印出参数的 size 属性呢？如果完全不进行约束 TS 是会报错的：

function trace<T>(arg: T): T {console.log(arg.size); // Error: Property 'size doesn't exist on type 'T'return arg;
}

报错的原因在于 T 理论上是可以是任何类型的，不同于 any，你不管使用它的什么属性或者方法都会报错（除非这个属性和方法是所有集合共有的）。那么直观的想法是限定传给 trace 函数的参数类型应该有 size 类型，这样就不会报错了。如何去表达这个类型约束的点呢？实现这个需求的关键在于使用类型约束。使用 extends 关键字可以做到这一点。简单来说就是你定义一个类型，然后让 T 实现这个接口即可。

interface Sizeable {size: number;
}
function trace<T extends Sizeable>(arg: T): T {console.log(arg.size);return arg;
}

有的人可能说我直接将 Trace 的参数限定为 Sizeable 类型可以么？如果你这么做，会有类型丢失的风险，详情可以参考这篇文章添加链接描述

泛型工具类型

为了方便开发者 TypeScript 内置了一些常用的工具类型，比如 Partial、Required、Readonly、Record 和 ReturnType 等。不过在具体介绍之前，我们得先介绍一些相关的基础知识，方便读者可以更好的学习其它的工具类型。

typeof
typeof 的主要用途是在类型上下文中获取变量或者属性的类型，下面我们通过一个具体示例来理解一下。

interface Person {name: string;age: number;
}
const sem: Person = { name: "semlinker", age: 30 };
type Sem = typeof sem; // type Sem = Person

在上面代码中，我们通过 typeof 操作符获取 sem 变量的类型并赋值给 Sem 类型变量，之后我们就可以使用 Sem 类型：

const lolo: Sem = { name: "lolo", age: 5 }

你也可以对嵌套对象执行相同的操作：

const Message = {name: "jimmy",age: 18,address: {province: '四川',city: '成都'   }
}
type message = typeof Message;
/*type message = {name: string;age: number;address: {province: string;city: string;};
}
*/

此外，typeof 操作符除了可以获取对象的结构类型之外，它也可以用来获取函数对象的类型，比如：

function toArray(x: number): Array<number> {return [x];
}
type Func = typeof toArray; // -> (x: number) => number[]

更多参考这里

类型守卫

类型保护是可执行运行时检查的一种表达式，用于确保该类型在一定的范围内。换句话说，类型保护可以保证一个字符串是一个字符串，尽管它的值也可以是一个数值。类型保护与特性检测并不是完全不同，其主要思想是尝试检测属性、方法或原型，以确定如何处理值。目前主要有四种的方式来实现类型保护：

in 关键字
typeof 关键字
instanceof 关键字
自定义类型保护的类型谓词
in 关键字

interface Admin {name: string;privileges: string[];
}interface Employee {name: string;startDate: Date;
}type UnknownEmployee = Employee | Admin;function printEmployeeInformation(emp: UnknownEmployee) {console.log("Name: " + emp.name);if ("privileges" in emp) {console.log("Privileges: " + emp.privileges);}if ("startDate" in emp) {console.log("Start Date: " + emp.startDate);}
}

typeof关键字

function padLeft(value: string, padding: string | number) {if (typeof padding === "number") {return Array(padding + 1).join(" ") + value;}if (typeof padding === "string") {return padding + value;}throw new Error(`Expected string or number, got '${padding}'.`);
}

typeof 类型保护只支持两种形式：typeof v === "typename" 和 typeof v !== typename，"typename" 必须是 "number"， "string"， "boolean" 或 "symbol"。但是 TypeScript 并不会阻止你与其它字符串比较，语言不会把那些表达式识别为类型保护。

instanceof 关键字

interface Padder {getPaddingString(): string;
}
class SpaceRepeatingPadder implements Padder {constructor(private numSpaces: number) {}getPaddingString() {return Array(this.numSpaces + 1).join(" ");}
}
class StringPadder implements Padder {constructor(private value: string) {}getPaddingString() {return this.value;}
}
let padder: Padder = new SpaceRepeatingPadder(6);if (padder instanceof SpaceRepeatingPadder) {// padder的类型收窄为 'SpaceRepeatingPadder'
}

自定义类型保护的类型谓词

function isNumber(x: any): x is number {return typeof x === "number";
}function isString(x: any): x is string {return typeof x === "string";
}

TypeScript 装饰器

装饰器介绍

它是一个表达式
该表达式被执行后，返回一个函数
函数的入参分别为 target、name 和 descriptor
执行该函数后，可能返回 descriptor 对象，用于配置 target 对象

装饰器分类

类装饰器（Class decorators）
属性装饰器（Property decorators）
方法装饰器（Method decorators）
参数装饰器（Parameter decorators）

需要注意的是，若要启用实验性的装饰器特性，你必须在命令行或 tsconfig.json 里启用 experimentalDecorators 编译器选项：

//命令行：
tsc --target ES5 --experimentalDecorators

//tsconfig.json
{"compilerOptions": {"target": "ES5","experimentalDecorators": true}
}

类装饰器

类装饰器声明：

declare type ClassDecorator = <TFunction extends Function>(target: TFunction
) => TFunction | void;

类装饰器顾名思义，就是用来装饰类的。它接收一个参数：

target: TFunction - 被装饰的类

function Greeter(target: Function): void {target.prototype.greet = function (): void {console.log("Hello Semlinker!");};
}@Greeter
class Greeting {constructor() {// 内部实现}
}let myGreeting = new Greeting();
(myGreeting as any).greet(); // console output: 'Hello Semlinker!';

上面的例子中，我们定义了 Greeter 类装饰器，同时我们使用了 @Greeter 语法糖，来使用装饰器。值得注意的是例子中总是输出 Hello Semlinker! ，下面我们自定义其他的内容：

function Greeter(greeting: string) {return function (target: Function) {target.prototype.greet = function (): void {console.log(greeting);};};
}@Greeter("Hello TS!")
class Greeting {constructor() {// 内部实现}
}let myGreeting = new Greeting();
(myGreeting as any).greet(); // console output: 'Hello TS!';

属性装饰器

declare type PropertyDecorator = (target:Object, propertyKey: string | symbol ) => void;

属性装饰器顾名思义，用来装饰类的属性。它接收两个参数：

target: Object - 被装饰的类
propertyKey: string | symbol - 被装饰类的属性名

我们定义了一个 logProperty 函数，来跟踪用户对属性的操作，代码如下：

function logProperty(target: any, key: string) {delete target[key];const backingField = "_" + key;Object.defineProperty(target, backingField, {writable: true,enumerable: true,configurable: true});// property getterconst getter = function (this: any) {const currVal = this[backingField];console.log(`Get: ${key} => ${currVal}`);return currVal;};// property setterconst setter = function (this: any, newVal: any) {console.log(`Set: ${key} => ${newVal}`);this[backingField] = newVal;};// Create new property with getter and setterObject.defineProperty(target, key, {get: getter,set: setter,enumerable: true,configurable: true});
}class Person { @logPropertypublic name: string;constructor(name : string) { this.name = name;}
}const p1 = new Person("semlinker");
p1.name = "kakuqo";

当代码成功运行后，在控制台会输出以下结果：

Set: name => semlinker
Set: name => kakuqo

方法装饰器

declare type MethodDecorator = <T>(target:Object, propertyKey: string | symbol, 	 	descriptor: TypePropertyDescript<T>) => TypedPropertyDescriptor<T> | void;

方法装饰器顾名思义，用来装饰类的方法。它接收三个参数：

target: Object - 被装饰的类
propertyKey: string | symbol - 方法名
descriptor: TypePropertyDescript - 属性描述符

下面给出一个例子：

function log(target: Object, propertyKey: string, descriptor: PropertyDescriptor) {let originalMethod = descriptor.value;descriptor.value = function (...args: any[]) {console.log("wrapped function: before invoking " + propertyKey);let result = originalMethod.apply(this, args);console.log("wrapped function: after invoking " + propertyKey);return result;};
}class Task {@logrunTask(arg: any): any {console.log("runTask invoked, args: " + arg);return "finished";}
}let task = new Task();
let result = task.runTask("learn ts");
console.log("result: " + result);

以上代码成功运行后，控制台会输出以下结果：

"wrapped function: before invoking runTask" 
"runTask invoked, args: learn ts" 
"wrapped function: after invoking runTask" 
"result: finished"

参数装饰器

declare type ParameterDecorator = (target: Object, propertyKey: string | symbol, parameterIndex: number ) => void

参数装饰器顾名思义，是用来装饰函数参数，它接收三个参数：

target: Object - 被装饰的类
propertyKey: string | symbol - 方法名
parameterIndex: number - 方法中参数的索引值

下面给出一个例子：

function Log(target: Function, key: string, parameterIndex: number) {let functionLogged = key || target.prototype.constructor.name;console.log(`The parameter in position ${parameterIndex} at ${functionLogged} hasbeen decorated`);
}class Greeter {greeting: string;constructor(@Log phrase: string) {this.greeting = phrase; }
}

以上代码成功运行后，控制台会输出以下结果：

"The parameter in position 0 at Greeter has been decorated"

tsconfig介绍

tsconfig.json 是 TypeScript 项目的配置文件。如果一个目录下存在一个 tsconfig.json 文件，那么往往意味着这个目录就是 TypeScript 项目的根目录。
tsconfig.json 包含 TypeScript 编译的相关配置，通过更改编译配置项，我们可以让 TypeScript 编译出 ES6、ES5、node 的代码。

tsconfig.json重要字段：

files - 设置要编译的文件的名称；
include - 设置需要进行编译的文件，支持路径模式匹配；
exclude - 设置无需进行编译的文件，支持路径模式匹配；
compilerOptions - 设置与编译流程相关的选项。

compilerOptions 选项：

{"compilerOptions": {/* 基本选项 */"target": "es5",                       // 指定 ECMAScript 目标版本: 'ES3' (default), 'ES5', 'ES6'/'ES2015', 'ES2016', 'ES2017', or 'ESNEXT'"module": "commonjs",                  // 指定使用模块: 'commonjs', 'amd', 'system', 'umd' or 'es2015'"lib": [],                             // 指定要包含在编译中的库文件"allowJs": true,                       // 允许编译 javascript 文件"checkJs": true,                       // 报告 javascript 文件中的错误"jsx": "preserve",                     // 指定 jsx 代码的生成: 'preserve', 'react-native', or 'react'"declaration": true,                   // 生成相应的 '.d.ts' 文件"sourceMap": true,                     // 生成相应的 '.map' 文件"outFile": "./",                       // 将输出文件合并为一个文件"outDir": "./",                        // 指定输出目录"rootDir": "./",                       // 用来控制输出目录结构 --outDir."removeComments": true,                // 删除编译后的所有的注释"noEmit": true,                        // 不生成输出文件"importHelpers": true,                 // 从 tslib 导入辅助工具函数"isolatedModules": true,               // 将每个文件做为单独的模块 （与 'ts.transpileModule' 类似）./* 严格的类型检查选项 */"strict": true,                        // 启用所有严格类型检查选项"noImplicitAny": true,                 // 在表达式和声明上有隐含的 any类型时报错"strictNullChecks": true,              // 启用严格的 null 检查"noImplicitThis": true,                // 当 this 表达式值为 any 类型的时候，生成一个错误"alwaysStrict": true,                  // 以严格模式检查每个模块，并在每个文件里加入 'use strict'/* 额外的检查 */"noUnusedLocals": true,                // 有未使用的变量时，抛出错误"noUnusedParameters": true,            // 有未使用的参数时，抛出错误"noImplicitReturns": true,             // 并不是所有函数里的代码都有返回值时，抛出错误"noFallthroughCasesInSwitch": true,    // 报告 switch 语句的 fallthrough 错误。（即，不允许 switch 的 case 语句贯穿）/* 模块解析选项 */"moduleResolution": "node",            // 选择模块解析策略： 'node' (Node.js) or 'classic' (TypeScript pre-1.6)"baseUrl": "./",                       // 用于解析非相对模块名称的基目录"paths": {},                           // 模块名到基于 baseUrl 的路径映射的列表"rootDirs": [],                        // 根文件夹列表，其组合内容表示项目运行时的结构内容"typeRoots": [],                       // 包含类型声明的文件列表"types": [],                           // 需要包含的类型声明文件名列表"allowSyntheticDefaultImports": true,  // 允许从没有设置默认导出的模块中默认导入。/* Source Map Options */"sourceRoot": "./",                    // 指定调试器应该找到 TypeScript 文件而不是源文件的位置"mapRoot": "./",                       // 指定调试器应该找到映射文件而不是生成文件的位置"inlineSourceMap": true,               // 生成单个 soucemaps 文件，而不是将 sourcemaps 生成不同的文件"inlineSources": true,                 // 将代码与 sourcemaps 生成到一个文件中，要求同时设置了 --inlineSourceMap 或 --sourceMap 属性/* 其他选项 */"experimentalDecorators": true,        // 启用装饰器"emitDecoratorMetadata": true          // 为装饰器提供元数据的支持}
}

其他

typeScript练习题

一份不可多得的 TS 学习指南

2022 typescript史上最强学习入门文章
typeScript中文网

TypeScript 开发辅助工具