一、原始数据类型

1.布尔值  在 TypeScript 中，使用 boolean 定义布尔值类型

2.数值  使用 number 定义数值类型

3.字符串  使用 string 定义字符串类型

4.空值  在 TypeScript 中，可以用 void 表示没有任何返回值的函数

5.Null 和 Undefined  在 TypeScript 中，可以使用 null 和 undefined 来定义这两个原始数据类型

二、任意值

任意值（Any）用来表示允许赋值为任意类型

在任意值上访问任何属性都是允许的，可以认为，声明一个变量为任意值之后，对它的任何操作，返回的内容的类型都是任意值

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

三、类型推论 

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

TypeScript 会在没有明确的指定类型的时候推测出一个类型，这就是类型推论。

如果定义的时候没有赋值，不管之后有没有赋值，都会被推断成 any 类型而完全不被类型检查

四、联合类型 

联合类型（Union Types）表示取值可以为多种类型中的一种

联合类型使用 | 分隔每个类型

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

当 TypeScript 不确定一个联合类型的变量到底是哪个类型的时候，我们只能访问此联合类型的所有类型里共有的属性或方法。

五、对象的类型—— 接口

在 TypeScript 中，我们使用接口（Interfaces）来定义对象的类型。

什么是接口:常用于对「对象的形状（Shape）」进行描述。

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

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

赋值的时候，变量的形状必须和接口的形状保持一致。

接口中还存在：可选属性、任意属性、只读属性。

六、数组的类型

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

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

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

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

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

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

七、函数的类型

函数声明：一个函数有输入和输出，要在 TypeScript 中对其进行约束，需要把输入和输出都考虑到，其中函数声明的类型定义较简单 

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;
};

其中，还有可选参数、参数默认值、剩余参数、重载

八、类型断言

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

语法：值 as 类型   或   <类型>值

类型断言的用途：

将一个联合类型断言为其中一个类型

将一个父类断言为更加具体的子类

将任何一个类型断言为 any

将 any 断言为一个具体的类型

九、类型别名

类型别名用来给一个类型起个新名字

简单的例子

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'), 'dblclick'); // 报错，event 不能为 'dblclick'

十一、元组

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

简单的例子

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

十二、类

类的概念

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

TypeScript 中类的用法 

public private 和 protected

TypeScript 可以使用三种访问修饰符（Access Modifiers），分别是 public、private 和 protected。

• public 修饰的属性或方法是公有的，可以在任何地方被访问到，默认所有的属性和方法都是 public 的
• private 修饰的属性或方法是私有的，不能在声明它的类的外部访问
• protected 修饰的属性或方法是受保护的，它和 private 类似，区别是它在子类中也是允许被访问的

十三、泛型

泛型（Generics）是指在定义函数、接口或类的时候，不预先指定具体的类型，而在使用的时候再指定类型的一种特性。

简单的例子

function fn<T>(arg:T):T{
    return arg
} 
let res = fn(123)

function swap<T,U>(fns:[T,U]) :[U,T]{
 return [fns[1],fns[0]]
}
let res2 = swap(['string',123])

 约束泛型  

 在函数内部使用泛型变量的时候，

由于事先不知道它是哪种类型，所以不能随意的操作它的属性或方法

interface lengths {
    length:number
}
// 我们使用了 extends 约束了泛型 T 必须符合接口 lengths 的形状
function asd<T extends lengths>(arg:T) :T{
    console.log(arg.length)
    return arg
}
let sss = asd('asd')
let arr = asd([1,2,3])
let obj = asd({length:112})

泛型在类中使用

class q<T> {
    private data = []
    push(item:T){
        return this.data.push(item)
    }
    pop():T{
        return this.data.shift()
    }
}
let s = new q()
s.push(1)

泛型在接口中的使用

interface k<T,U> {
    key:T,
    value:U
}
let k1:k<number, string> = {key:1,value:"123"}
let k2:k<string,number > = {key:'1',value:123}