TypeScript

1.基础类型：

boolean
number
string
数组：number[ ]/数据泛型方式 Array
元组tuple：数组的一种，用来表示一个已知元素数量和类型的数组；let arr:[number , string] = [10 , 'test' ]
枚举enum：从0开始为元素编号。也可以手动的指定成员的数值,数值会递增。可以由枚举的值得到它的名字，也可以由名字得到相应的值

enum Color {
  Red,
  Blue,
}
let b: string;
let a: number;
a = Color.Red; // 0
b = Color[0]; // 'Red'

any
void：表示没有任何类型
null / undefined：默认情况下是所有类型的子类型，当指定了--strictNullChecks标记，null和undefined只能赋值给void和它们各自
never：永不存在的值的类型
object：非原始类型，即除number，string，boolean，symbol，null或undefined之外的类型

2.接口类型interface

可以用来描述一个对象或者函数

interface Config {
    width: number;
    color?: string; // 可选属性
    readonly id: string; // 只读属性
    childs: ReadonlyArray; // ts具有ReadonlyArray类型，与Array相似，只是把所有可变方法去掉了
    [propName: string]: any; // 任意属性，任意数量的其它属性
}

interface Fun {
    (name:string, age:number): void
}

接口继承(扩展):extends

interface Shape {
    color: string;
}

interface PenStroke {
    penWidth: number;
}

interface Square extends Shape, PenStroke { // 可以一次继承多个
    sideLength: number;
}

let square = {}; // 断言
square.color = "blue";
square.sideLength = 10;
square.penWidth = 5.0;

4.函数类型

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

// 将输入输出类型分别指定，为函数定义类型
let myAdd = function(x: number, y: number): number { return x + y; };

// 将函数整体定义指向函数变量,即书写完整函数类型
let myAdd: (baseValue: number, increment: number) => number = function(x, y) { return x + y; };
// 将函数以接口形式定义指向给函数变量,函数接口类型
let myAdd: {(baseValue: number, increment: number):number} = function(x, y) { return x + y; };

只要参数类型是匹配的，那么就认为它是有效的函数类型，而不在乎参数名是否正确

5.泛型：

泛型就是指在定义函数、接口或者类的时候不预先指定具体的类型，而在使用的时候在指定类型的一种特性
泛型在函数中的应用：

// 将输入输出类型分别指定
function test1(arg:T[ ]):T[ ]{ return arg; }
const test2 = (arg:P):P=> arg;

// 定义函数整体类型的方式
const test3:(val:U)=>U = val => val;

// 接口定义函数的形式
const test4: { (val:T): T} = val => val;

在接口中的应用：

interface Props {
  dataSource: T[];
}

在类型别名中的应用：

type Props = {
  dataSource: T[];
}

6.高级类型

联合类型：type C = A | B; C满足A或者满足B(联合类型表示一个值可以是几种类型之一，对象联合类型只能访问联合中所有共同成员)
交叉类型：type C = A & B; C即满足A又满足B(交叉类型是将多个类型合并为一个类型，对象交叉类型能访问联合中所有成员)
类型别名type：和接口很像，也可以用来描述对象或者函数,但是可以作用于原始值，联合类型，元组以及其它任何你需要手写的类型

type Name = string;
type Config =  {
    width: number;
    color?: string; // 可选属性
    other?: T; // 可以是泛型
}

type Fun = (name:string, age:number): void

类型别名不能被 extends和 implements（自己也不能 extends和 implements其它类型）
无法通过接口来描述一个类型并且需要使用联合类型或元组类型，这时通常会使用类型别名。

索引类型 keyof / T[K]

function pluck(o: T, names: K[]): T[K][] {
  return names.map(n => o[n]);
}

interface Person {
    name: string;
    age: number;
}
let person: Person = {
    name: 'Jarid',
    age: 35
};
let strings: string[] = pluck(person, ['name']); // ok, string[]---> ['Jarid']

keyof T 索引类型查询操作符，其的结果为 T上已知的公共属性名的联合
T[K] 索引类型访问操作符

映射类型 in

type Keys = 'option1' | 'option2';
type Flags = { [K in Keys]: boolean };
// Partial是ts内置的工具类型，源码如下：
type Partial = { [P in keyof T]?: T[P] }
// 作用：生成一个新类型，该类型与 T 拥有相同的属性，但是所有属性皆为可选项
interface Foo {
    name: string
    age: number
}
type Bar = Partial

ts库里还有其他的一些工具类型，如Readonly / Pick / Record / Exclude/ Extract...

类型断言：<类型>值 / 值 as 类型（）

模块

TypeScript与ECMAScript 2015一样，任何包含顶级import或者export的文件都被当成一个模块。相反地，如果一个文件不带有顶级的import或者export声明，那么它的内容被视为全局可见的（因此对模块也是可见的）