typescript部分笔记

typescript

安装

npm install -g typescript



创建一个文件 hello.ts

随便输入内容


然后编译

tsc hello.ts



----------------------------

声明变量

let isDone: boolean = false;

// 
编译通过
// 后面约定，未强调编译错误的代码片段，默认为编译通过


----------------------------


使用 number 定义数值类型：


let decLiteral: number = 6;

let hexLiteral: number = 0xf00d;
// ES6 中的二进制表示法

let binaryLiteral: number = 0b1010;
// ES6 中的八进制表示法

let octalLiteral: number = 0o744;
let notANumber: number = NaN;

let infinityNumber: number = Infinity;



----------------------------

字符串



let myName: string = 'Tom';

let myAge: number = 25;

// 模板字符串

let sentence: string = `Hello, my name is ${myName}.
I'll be ${myAge + 1} years old next month.`;


----------------------------

函数返回空值

function alertName(): void {
    alert('My name is Tom');
}


----------------------------


任意值

Any



let myFavoriteNumber: string = 'seven';
m
yFavoriteNumber = 7;

//上面的写法会报错



//下面的就不会
let myFavoriteNumber: any = 'seven';

myFavoriteNumber = 7;




any 可以在宽松模式下使用 或者在别的场景下使用



----------------------------


联合类型


let myFavoriteNumber: string | number;

myFavoriteNumber = 'seven';

myFavoriteNumber = 7;



//访问联合类型的属性或方法
function getLength(something: string | number): number 
{
    return something.length;
}

--------------------------------------------------------

对象的类型——接口


interface Person {
    name: string;
    age: number;
}

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


上面的例子中，我们定义了一个接口 Person，
接着定义了一个变量 tom，它的类型是 Person。
这样，我们就约束了 tom 的形状必须和接口 Person 一致。
接口一般首字母大写



--------------------------------------------------------
对象的类型——接口

interface Person {
    name: string;
    age?: number;
}

let tom: Person = {
    name: 'Tom'
};


有时我们希望不要完全匹配一个形状，那么可以用可选属性：




--------------------------------------------------------

对象的类型——接口


有时候我们希望一个接口允许有任意的属性，可以使用如下方式：



interface Person {
    name: string;
    age?: number;
    [propName: string]: any;
}

let tom: Person = {
    name: 'Tom',
    gender: 'male'
};


使用 [propName: string] 定义了任意属性取 string 类型的值。




--------------------------------------------------------

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



interface Person {
    name: string;
    age?: number;
    [propName: string]: string;
}

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



上例中，任意属性的值允许是 string，
但是可选属性 age 的值却是 number，number 
不是 string 的子属性，所以报错了。

另外，在报错信息中可以看出，此时
 { name: 'Tom', age: 25, gender: 'male' } 
的类型被推断成了 { [x: string]: string | number;
 name: string; age: number; gender: string; }，
这是联合类型和接口的结合。


--------------------------------------------------------


接口 只读属性



有时候我们希望对象中的一些字段只能在创建的时候被赋值，
那么可以用 readonly 定义只读属性：



interface Person {
    readonly id: number;
    name: string;
    age?: number;
    [propName: string]: any;
}

let tom: Person = {
    id: 89757,
    name: 'Tom',
    gender: 'male'
};

tom.id = 9527;//报错



--------------------------------------------------------
--------------------------------------------------------
--------------------------------------------------------


数组的类型


在 TypeScript 中，数组类型有多种定义方式，比较灵活。


最简单的方法是使用「类型 + 方括号」来表示数组：

let fibonacci: number[] = [1, 1, 2, 3, 5];




数组的项中不允许出现其他的类型：


let fibonacci: number[] = [1, '1', 2, 3, 5];




数组泛型


我们也可以使用数组泛型（Array Generic） Array<elemType> 来表示数组：

let fibonacci: Array<number> = [1, 1, 2, 3, 5];


--------------------------------------------------------


用接口表示数组



接口也可以用来描述数组：

interface NumberArray {
    [index: number]: number;
}
let fibonacci: NumberArray = [1, 1, 2, 3, 5];




--------------------------------------------------------



类数组


上例中，arguments 实际上是一个类数组，不能用普通的数组的方式来描述，而应该用接口：


function sum() {
    let args: number[] = arguments;
}


其中 IArguments 是 TypeScript 中定义好了的类型，它实际上就是：



interface IArguments {
    [index: number]: any;
    length: number;
    callee: Function;
}







--------------------------------------------------------

any 在数组中的应用



一个比较常见的做法是，用 any 表示数组中允许出现任意类型：




let list: any[] = ['xcatliu', 25, { website: 'http://xcatliu.com' }];




--------------------------------------------------------


函数的类型


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




let mySum: (x: number, y: number) => number = function (x: number, y: number): number {
    return x + y;
};


在 TypeScript 的类型定义中，=> 用来表示函数的定义，
左边是输入类型，需要用括号括起来，右边是输出类型。


--------------------------------------------------------



用接口定义函数的形状

我们也可以使用接口的方式来定义一个函数需要符合的形状：


interface SearchFunc {
    (source: string, subString: string): boolean;
}

let mySearch: SearchFunc;
mySearch = function(source: string, subString: string) {
    return source.search(subString) !== -1;
}


--------------------------------------------------------


可选参数

前面提到，输入多余的（或者少于要求的）参数，是不允许的。那么如何定义可选的参数呢？



function buildName(firstName: string, lastName?: string) {
    if (lastName) {
        return firstName + ' ' + lastName;
    } else {
        return firstName;
    }
}
let tomcat = buildName('Tom', 'Cat');
let tom = buildName('Tom');


需要注意的是，可选参数必须接在必需参数后面。
换句话说，可选参数后面不允许再出现必需参数了：

--------------------------------------------------------




参数默认值


在 ES6 中，我们允许给函数的参数添加默认值，
TypeScript 会将添加了默认值的参数识别为可选参数：


function buildName(firstName: string, lastName: string = 'Cat') {
    return firstName + ' ' + lastName;
}
let tomcat = buildName('Tom', 'Cat');
let tom = buildName('Tom');

此时就不受「可选参数必须接在必需参数后面」的限制了：



function buildName(firstName: string = 'Tom', lastName: string) {
    return firstName + ' ' + lastName;
}
let tomcat = buildName('Tom', 'Cat');
let cat = buildName(undefined, 'Cat');


--------------------------------------------------------


剩余参数
ES6 中，可以使用 ...rest 的方式获取函数中的剩余参数（rest 参数）：

function push(array: any[], ...items: any[]) {
    items.forEach(function(item) {
        array.push(item);
    });
}
let a = [];
push(a, 1, 2, 3);

注意，rest 参数只能是最后一个参数，关于 rest 参数，可以参考 ES6 中的 rest 参数。



--------------------------------------------------------


https://ts.xcatliu.com/basics/type-of-function



函数的类型

重载

重载允许一个函数接受不同数量或类型的参数时，作出不同的处理

function reverse(x: number): number;
function reverse(x: string): string;
function reverse(x: number | string): number | string {
    if (typeof x === 'number') {
        return Number(x.toString().split('').reverse().join(''));
    } else if (typeof x === 'string') {
        return x.split('').reverse().join('');
    }
}


--------------------------------------------------------


类型断言

类型断言（Type Assertion）可以用来手动指定一个值的类型。


<类型>值


值 as 类型



--------------------------------------------------------


声明文件

--------------------------------------------------------

内置对象





--------------------------------------------------------


进阶


类型别名


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


--------------------------------------------------------

字符串字面量类型

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



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'



--------------------------------------------------------


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



简单的例子

定义一对值分别为 string 和 number 的元组：



let tom: [string, number] = ['Tom', 25];



--------------------------------------------------------

当赋值或访问一个已知索引的元素时，会得到正确的类型：

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'];
报错


--------------------------------------------------------

越界的元素

当添加越界的元素时，
它的类型会被限制为元组中每个类型的联合类型：



let tom: [string, number];

tom = ['Tom', 25];

tom.push('male');

tom.push(true);
报错





--------------------------------------------------------

枚举

枚举（Enum）类型用于取值被限定在一定范围内的场景，
比如一周只能有七天，颜色限定为红绿蓝等。


枚举使用 enum 关键字来定义：



enum Days {Sun, Mon, Tue, Wed, Thu, Fri, Sat};




--------------------------------------------------------

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



--------------------------------------------------------

上面的例子中，未手动赋值的枚举项会接着上一个枚举项递增。


如果未手动赋值的枚举项与手动赋值的重复了，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


上面的例子中，递增到 3 的时候与前面的 Sun 的取值重复了，
但是 TypeScript 并没有报错，导致 Days[3] 的值先是 "Sun"，
而后又被 "Wed" 覆盖了。编译的结果是：


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 = {}));
--------------------------------------------------------

手动赋值的枚举项可以不是数字，此时需要使用类型断言来让 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：



enum Days {Sun = 7, Mon = 1.5, Tue, Wed, Thu, Fri, Sat};

console.log(Days["Sun"] === 7); // true
console.log(Days["Mon"] === 1.5); // true
console.log(Days["Tue"] === 2.5); // true
console.log(Days["Sat"] === 6.5); // true

--------------------------------------------------------

class

https://ts.xcatliu.com/advanced/class

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



--------------------------------------------------------






--------------------------------------------------------

　　

typescript
安装
npm install -g typescript


创建一个文件 hello.ts
随便输入内容

然后编译
tsc hello.ts


----------------------------
声明变量
let isDone: boolean = false;
// 编译通过// 后面约定，未强调编译错误的代码片段，默认为编译通过

----------------------------

使用 number 定义数值类型：

let decLiteral: number = 6;
let hexLiteral: number = 0xf00d;// ES6 中的二进制表示法
let binaryLiteral: number = 0b1010;// ES6 中的八进制表示法
let octalLiteral: number = 0o744;let notANumber: number = NaN;
let infinityNumber: number = Infinity;


----------------------------
字符串


let myName: string = 'Tom';
let myAge: number = 25;
// 模板字符串
let sentence: string = `Hello, my name is ${myName}.I'll be ${myAge + 1} years old next month.`;

----------------------------
函数返回空值
function alertName(): void {    alert('My name is Tom');}

----------------------------

任意值
Any


let myFavoriteNumber: string = 'seven';myFavoriteNumber = 7;
//上面的写法会报错


//下面的就不会let myFavoriteNumber: any = 'seven';
myFavoriteNumber = 7;



any 可以在宽松模式下使用 或者在别的场景下使用


----------------------------

联合类型

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


//访问联合类型的属性或方法function getLength(something: string | number): number {    return something.length;}
--------------------------------------------------------
对象的类型——接口

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

上面的例子中，我们定义了一个接口 Person，接着定义了一个变量 tom，它的类型是 Person。这样，我们就约束了 tom 的形状必须和接口 Person 一致。接口一般首字母大写


--------------------------------------------------------对象的类型——接口
interface Person {    name: string;    age?: number;}
let tom: Person = {    name: 'Tom'};

有时我们希望不要完全匹配一个形状，那么可以用可选属性：



--------------------------------------------------------
对象的类型——接口

有时候我们希望一个接口允许有任意的属性，可以使用如下方式：


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

使用 [propName: string] 定义了任意属性取 string 类型的值。



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


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


上例中，任意属性的值允许是 string，但是可选属性 age 的值却是 number，number 不是 string 的子属性，所以报错了。
另外，在报错信息中可以看出，此时 { name: 'Tom', age: 25, gender: 'male' } 的类型被推断成了 { [x: string]: string | number; name: string; age: number; gender: string; }，这是联合类型和接口的结合。

--------------------------------------------------------

接口 只读属性


有时候我们希望对象中的一些字段只能在创建的时候被赋值，那么可以用 readonly 定义只读属性：


interface Person {    readonly id: number;    name: string;    age?: number;    [propName: string]: any;}
let tom: Person = {    id: 89757,    name: 'Tom',    gender: 'male'};
tom.id = 9527;//报错


------------------------------------------------------------------------------------------------------------------------------------------------------------------------

数组的类型

在 TypeScript 中，数组类型有多种定义方式，比较灵活。

最简单的方法是使用「类型 + 方括号」来表示数组：
let fibonacci: number[] = [1, 1, 2, 3, 5];



数组的项中不允许出现其他的类型：

let fibonacci: number[] = [1, '1', 2, 3, 5];



数组泛型

我们也可以使用数组泛型（Array Generic） Array<elemType> 来表示数组：
let fibonacci: Array<number> = [1, 1, 2, 3, 5];

--------------------------------------------------------

用接口表示数组


接口也可以用来描述数组：
interface NumberArray {    [index: number]: number;}let fibonacci: NumberArray = [1, 1, 2, 3, 5];



--------------------------------------------------------


类数组

上例中，arguments 实际上是一个类数组，不能用普通的数组的方式来描述，而应该用接口：

function sum() {    let args: number[] = arguments;}

其中 IArguments 是 TypeScript 中定义好了的类型，它实际上就是：


interface IArguments {    [index: number]: any;    length: number;    callee: Function;}






--------------------------------------------------------
any 在数组中的应用


一个比较常见的做法是，用 any 表示数组中允许出现任意类型：



let list: any[] = ['xcatliu', 25, { website: 'http://xcatliu.com' }];



--------------------------------------------------------

函数的类型

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



let mySum: (x: number, y: number) => number = function (x: number, y: number): number {    return x + y;};

在 TypeScript 的类型定义中，=> 用来表示函数的定义，左边是输入类型，需要用括号括起来，右边是输出类型。

--------------------------------------------------------


用接口定义函数的形状
我们也可以使用接口的方式来定义一个函数需要符合的形状：

interface SearchFunc {    (source: string, subString: string): boolean;}
let mySearch: SearchFunc;mySearch = function(source: string, subString: string) {    return source.search(subString) !== -1;}

--------------------------------------------------------

可选参数
前面提到，输入多余的（或者少于要求的）参数，是不允许的。那么如何定义可选的参数呢？


function buildName(firstName: string, lastName?: string) {    if (lastName) {        return firstName + ' ' + lastName;    } else {        return firstName;    }}let tomcat = buildName('Tom', 'Cat');let tom = buildName('Tom');

需要注意的是，可选参数必须接在必需参数后面。换句话说，可选参数后面不允许再出现必需参数了：
--------------------------------------------------------



参数默认值

在 ES6 中，我们允许给函数的参数添加默认值，TypeScript 会将添加了默认值的参数识别为可选参数：

function buildName(firstName: string, lastName: string = 'Cat') {    return firstName + ' ' + lastName;}let tomcat = buildName('Tom', 'Cat');let tom = buildName('Tom');
此时就不受「可选参数必须接在必需参数后面」的限制了：


function buildName(firstName: string = 'Tom', lastName: string) {    return firstName + ' ' + lastName;}let tomcat = buildName('Tom', 'Cat');let cat = buildName(undefined, 'Cat');

--------------------------------------------------------

剩余参数ES6 中，可以使用 ...rest 的方式获取函数中的剩余参数（rest 参数）：
function push(array: any[], ...items: any[]) {    items.forEach(function(item) {        array.push(item);    });}let a = [];push(a, 1, 2, 3);
注意，rest 参数只能是最后一个参数，关于 rest 参数，可以参考 ES6 中的 rest 参数。


--------------------------------------------------------

https://ts.xcatliu.com/basics/type-of-function


函数的类型
重载
重载允许一个函数接受不同数量或类型的参数时，作出不同的处理
function reverse(x: number): number;function reverse(x: string): string;function reverse(x: number | string): number | string {    if (typeof x === 'number') {        return Number(x.toString().split('').reverse().join(''));    } else if (typeof x === 'string') {        return x.split('').reverse().join('');    }}

--------------------------------------------------------

类型断言
类型断言（Type Assertion）可以用来手动指定一个值的类型。

<类型>值

值 as 类型


--------------------------------------------------------

声明文件
--------------------------------------------------------
内置对象




--------------------------------------------------------

进阶

类型别名

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

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


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'


--------------------------------------------------------

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


简单的例子
定义一对值分别为 string 和 number 的元组：


let tom: [string, number] = ['Tom', 25];


--------------------------------------------------------
当赋值或访问一个已知索引的元素时，会得到正确的类型：
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'];报错

--------------------------------------------------------
越界的元素
当添加越界的元素时，它的类型会被限制为元组中每个类型的联合类型：


let tom: [string, number];
tom = ['Tom', 25];
tom.push('male');
tom.push(true);报错




--------------------------------------------------------
枚举
枚举（Enum）类型用于取值被限定在一定范围内的场景，比如一周只能有七天，颜色限定为红绿蓝等。

枚举使用 enum 关键字来定义：


enum Days {Sun, Mon, Tue, Wed, Thu, Fri, Sat};



--------------------------------------------------------
enum Days {Sun, Mon, Tue, Wed, Thu, Fri, Sat};
console.log(Days["Sun"] === 0); // trueconsole.log(Days["Mon"] === 1); // trueconsole.log(Days["Tue"] === 2); // trueconsole.log(Days["Sat"] === 6); // true
console.log(Days[0] === "Sun"); // trueconsole.log(Days[1] === "Mon"); // trueconsole.log(Days[2] === "Tue"); // trueconsole.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, Tue, Wed, Thu, Fri, Sat};
console.log(Days["Sun"] === 7); // trueconsole.log(Days["Mon"] === 1); // trueconsole.log(Days["Tue"] === 2); // trueconsole.log(Days["Sat"] === 6); // true


--------------------------------------------------------
上面的例子中，未手动赋值的枚举项会接着上一个枚举项递增。

如果未手动赋值的枚举项与手动赋值的重复了，TypeScript 是不会察觉到这一点的：

enum Days {Sun = 3, Mon = 1, Tue, Wed, Thu, Fri, Sat};
console.log(Days["Sun"] === 3); // trueconsole.log(Days["Wed"] === 3); // trueconsole.log(Days[3] === "Sun"); // falseconsole.log(Days[3] === "Wed"); // true

上面的例子中，递增到 3 的时候与前面的 Sun 的取值重复了，但是 TypeScript 并没有报错，导致 Days[3] 的值先是 "Sun"，而后又被 "Wed" 覆盖了。编译的结果是：

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 = {}));--------------------------------------------------------
手动赋值的枚举项可以不是数字，此时需要使用类型断言来让 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：


enum Days {Sun = 7, Mon = 1.5, Tue, Wed, Thu, Fri, Sat};
console.log(Days["Sun"] === 7); // trueconsole.log(Days["Mon"] === 1.5); // trueconsole.log(Days["Tue"] === 2.5); // trueconsole.log(Days["Sat"] === 6.5); // true
--------------------------------------------------------
class
https://ts.xcatliu.com/advanced/class
class Animal {    public name;    public constructor(name) {        this.name = name;    }}
let a = new Animal('Jack');console.log(a.name); // Jacka.name = 'Tom';console.log(a.name); // Tom


--------------------------------------------------------





--------------------------------------------------------