TS 学习笔记

声明文件

全局变量的声明文件主要有以下几种语法：

declare var 声明全局变量
declare function 声明全局方法
declare class 声明全局类
declare enum 声明全局枚举类型
declare namespace 声明（含有子属性的）全局对象
interface 和 type 声明全局类型​

declare function jQuery(selector: string): any;
declare namespace jQuery {
    function ajax(url: string, settings?: any): void;
}

基础类型 & 常用类型定义

number ｜ string ｜ boolean | any[] ｜ undefined | null | Turple | Enum |
void | any | never | object(非基础类型)

数组定义方式：

1. 「类型 + 方括号」表示法：eg. number[] ｜ any[]
2. 数组泛型：eg. Array
3. 接口表示数组

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

4. 类表示数组 (不建议用)

function sum() {
    let args: IArguments = arguments;
}
// IArguments 是 TypeScript 中定义好了的类型
interface IArguments {
    [index: number]: any;
    length: number;
    callee: Function;
}

ECMAScript 标准提供的内置对象有：Boolean、Error、Date、RegExp 等。
DOM 和 BOM 提供的内置对象有：Document、HTMLElement、Event、NodeList 等。
内置对象可以在TS中直接使用

枚举

enum Days {Sun, Mon, Tue, Wed, Thu, Fri, Sat};
// 编译后
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 = {}));

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

类型 & 接口（接口一般首字母大写，建议 “I” 开头）

接口不允许添加未定义的属性，也不允许确实必要的属性，一个接口中只能定义一个任意属性。如果接口中有多个类型的属性，则可以在任意属性中使用联合类型：

// 类型别名
type Name = string;
type NameResolver = () => string;
type NameOrResolver = Name | NameResolver;

// 任意类型属性定义方式
interface Person {
	// 只读属性
	readonly id:string;
	// 必要属性
    name: string;
    // 可选属性
    age?: number;
    // 任意属性
    [propName: string]: number ｜ string;
}

类型和接口定义相似，尽可能使用interface，便于扩展
「type 」& 「type 」、「type 」& 「interface 」、「interface」extends 「interface 」、 「interface」extends 「type 」

类型推论 & 联合类型

// eg. 
let myFavoriteNumber = 'seven';
// 等价于
let myFavoriteNumber:string = 'seven';

// 联合类型 
let myStringNumber: string | number;
// 只能访问联合类型的共同属性
myStringNumber.length // error
myStringNumber.toString() // success

函数类型

注意不要混淆了 TypeScript 中的 => 和 ES6 中的 =>。
在 TypeScript 的类型定义中，=> 用来表示函数的定义，左边是输入类型，需要用括号括起来，右边是输出类型。
可选参数必须接在必需参数后面。换句话说，可选参数后面不允许再出现必需参数了：

// 重载
function reverse(x: number): number;
function reverse(x: string): string;
// 声明合并
function reverse(x: number | string): number | string {}
// 函数表达式 可选参数有默认值，不受可选必在必需后面限制
let mySum: ((x: number, y: number) => number) = function (x1?: number = 0,x: number, y?: number): number {
    return x1 + x + y;
};

类型断言

• 联合类型可以被断言为其中一个类型
• 父类可以被断言为子类
• 任何类型都可以被断言为 any
• any 可以被断言为任何类型
• 要使得 A 能够被断言为 B，只需要 A 兼容 B 或 B 兼容 A 即可

interface Animal {
    name: string;
}
interface Cat {
    name: string;
    run(): void;
}

function testAnimal(animal: Animal) {
    return (animal as Cat);
}
function testCat(cat: Cat) {
    return (cat as Animal);
}

function testCat(cat: Cat) {
// **双重断言**
    return (cat as any as Fish);
}
// Animal 兼容 Cat 
let tom = animal as Cat; // ok
// animal 赋值给 tom，需要满足 Cat 兼容 Animal 才行
let tom: Cat = animal; // error

扩展阅读：
类（Class）：定义了一件事物的抽象特点，包含它的属性和方法
对象（Object）：类的实例，通过 new 生成
面向对象（OOP）的三大特性：封装、继承、多态
封装（Encapsulation）：将对数据的操作细节隐藏起来，只暴露对外的接口。外界调用端不需要（也不可能）知道细节，就能通过对外提供的接口来访问该对象，同时也保证了外界无法任意更改对象内部的数据
继承（Inheritance）：子类继承父类，子类除了拥有父类的所有特性外，还有一些更具体的特性
多态（Polymorphism）：由继承而产生了相关的不同的类，对同一个方法可以有不同的响应。比如 Cat 和 Dog 都继承自 Animal，但是分别实现了自己的 eat 方法。此时针对某一个实例，我们无需了解它是 Cat 还是 Dog，就可以直接调用 eat 方法，程序会自动判断出来应该如何执行 eat
存取器（getter & setter）：用以改变属性的读取和赋值行为
修饰符（Modifiers）：修饰符是一些关键字，用于限定成员或类型的性质。比如 public 表示公有属性或方法
抽象类（Abstract Class）：抽象类是供其他类继承的基类，抽象类不允许被实例化。抽象类中的抽象方法必须在子类中被实现
接口（Interfaces）：不同类之间公有的属性或方法，可以抽象成一个接口。接口可以被类实现（implements）。一个类只能继承自另一个类，但是可以实现多个接口

allowJs boolean false 允许编译 js 文件
allowSyntheticDefaultImports boolean false 允许对不包含默认导出的模块使用默认导入。这个选项不会影响生成的代码，只会影响类型检查。

​