1、类型

一、基础类型

布尔值
let isDone: boolean = false;

数字
let decLiteral: number = 6;

字符串
let name: string = "bob";

数组
let list: number[] = [1, 2, 3];

元组 Tuple
let x: [string, number]; x = ['hello', 10];

枚举(enumeration [ɪˌnjuːməˈreɪʃn])
enum Color {Red, Green, Blue} let c: Color = Color.Green; //1 let d: string = Color[1]; //Green

Any
let notSure: any = 4; notSure = "maybe a string instead"; notSure = false; // okay, definitely a boolean

跟object不一样，any的话可以调用里面的方法，object只能读取属性

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

let unusable: void = undefined; //void只能变成null / undefined

Null 和 Undefined
let u: undefined = undefined; let n: null = null;

Never

never类型是那些总是会抛出异常或根本就不会有返回值的函数表达式或箭头函数表达式的返回值类型
never类型是任何类型的子类型，也可以赋值给任何类型；然而，没有类型是never的子类型或可以赋值给never类型（除了never本身之外）。 即使 any也不可以赋值给never。

`

// 返回never的函数必须存在无法达到的终点

function error(message: string): never {

throw new Error(message);

}

// 推断的返回值类型为never

function fail() {

return error("Something failed");

}
// 返回never的函数必须存在无法达到的终点

function infiniteLoop(): never {

while (true) {

}

} 

`

Object

object表示非原始类型，也就是除number，string，boolean，symbol，null或undefined之外的类型。

使用object类型，就可以更好的表示像Object.create这样的API。例如：

`

declare function create(o: object | null): void;

create({ prop: 0 }); // OK

create(null); // OK
create(42); // Error

create("string"); // Error

create(false); // Error

create(undefined); // Error

`

二、类型断言

类型断言好比其它语言里的类型转换，但是不进行特殊的数据检查和解构。 它没有运行时的影响，只是在编译阶段起作用。 TypeScript会假设你，程序员，已经进行了必须的检查。
类型断言有两种形式。 其一是“尖括号”语法：
<pre> let someValue: any = "this is a string"; let strLength: number = (<string>someValue).length; </pre>

另一个为as语法：
<pre> let someValue: any = "this is a string"; let strLength: number = (someValue as string).length; </pre>

双层断言
function handler(event: Event) { const element = (event as any) as HTMLElement; // ok }

三、联合类型

<pre> function getString(something: string | number): string { return something.toString(); }
// 只能访问此联合类型的所有类型里共有的属性或方法

四、对象类型（接口）

简单例子
`

interface Person {

name: string;

age: number;

}

let tom: Person = {

name: 'Tom',

age: 25

};

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

`interface Person {

name: string;

age?: number;

[propName: string]: string;

}
let tom: Person = {

name: 'Tom',

age: 25,

gender: 'male'

};` //这是错误的。上例中，任意属性的值允许是 string，但是可选属性 age 的值却是 number，number 不是 string 的子属性，所以报错了。
应改为

`interface Person {

name: string;

age?: number;

[propName: string]: string | number;

}
let tom: Person = {

name: 'Tom',

age: 25,

gender: 'male'

};`
只读属性

readonly id: number;

注意，只读的约束存在于第一次给对象赋值的时候，而不是第一次给只读属性赋值的时候
五、数组类型
1、「类型 + 方括号」表示法

let fibonacci: number[] = [1, 1, 2, 3, 5];
2、数组泛型

let fibonacci: Array<number> = [1, 1, 2, 3, 5];
3、用接口表示数组

interface NumberArray {     [index: number]: number; } let fibonacci: NumberArray = [1, 1, 2, 3, 5];
六、函数类型
1、函数声明

function sum(x: number, y: number): number {     return x + y; }
2、函数表达式

let mySum = function (x: number, y: number): number {     return x + y; };
let mySum: (x: number, y: number) => number = function (x: number, y: number): number {     return x + y; };
3、用接口定义函数的形状

`interface SearchFunc {

(source: string, subString: string): boolean;

}
let mySearch: SearchFunc;

mySearch = function(source: string, subString: string) {

return source.search(subString) !== -1;

}`
4、可选参数

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

可选参数后面不允许再出现必需参数
5、参数默认值

function buildName(firstName: string = 'Tom', lastName: string) {     return firstName + ' ' + lastName; } let tomcat = buildName('Tom', 'Cat'); let cat = buildName(undefined, 'Cat');
6、剩余参数

`function push(array: any[], ...items: any[]) {

items.forEach(function(item) {

array.push(item);

});

}
let a = [];

push(a, 1, 2, 3);`