基础类型

布尔值

最基本的数据类型就是简单的 true、false值

let isDone: boolean = true

数字

TypeScript里的所有的数字都是浮点数,这些浮点数的类型就是 number

let age: number = 18

字符串

我们使用 string 表示文本数据类型,和javascript一样我们可以使用双引号 " 、单引号 ' 表示字符串

let name: string = 'busyhe'

数组

有两种方式可以定义数组:第一种是由次类型元素组成的数组,类型[]

let list: number[] = [1, 2, 3]

第二种数组泛型Array<元素类型>

let list:Array<number> = [1, 2, 3]

元组Tuple

元组表示一个已知元素数量和类型的数组

let list: [string, number];
list = ['Hello', 1] // OK
list = [1, 'Hello'] // Error

枚举enum

为一组数值赋予友好的名字,默认情况下从 0 开始为元素编号

enum Color {RED, GREEN}
let a: Color = Color.RED // a = 0

或者手动赋值

enum Color {RED = 1, GREEN = 'green'}
let a: Color = Color.RED // a = 1

也可以反向取值

enum Color {RED = 1, GREEN}
let a: string = Color[2] // a = 'GREEN'

any

名如其义,如果不清楚变量为什么类型,这时候我们可以使用 any 类型来标记

let a: any = 4
a = '123'
a = false

void

与any类型相反,表示没有任何类型。当一个函数没有返回值的时候

function a(): void {
    console.log('this is a log')   
}

声明一个 void 的变量你只能赋值为 undefinednull

let a: void = undefined
void = null

null、undefined

null 和 undefined 各自有自己的类型分别为undefined和null。

let a: undefined = undefined
let a: null = null

默认情况下 null 和 undefined为所有类型的子类型,比如你可以把undefined 和 null 赋值给number类型的变量

let a: number = 1
a = undefined

但是你如果指定了 --strictNullChecks , null 和 undefined 只能指定 void 和各自自己的类型

Never

永远不存在的类型,例如抛出异常或没有返回值的函数。never为任何类型的子类型

function error(): never { 
    throw new Error('error')
}

object

非原始类型,除number、string、boolean、symbol、null、undefined之外的类型

create(o: object | null)

create({user: '123'}) // OK
create(null) // OK

create(42) // error
create('123') // error

类型断言

通过类型断言可以明确的表示某个值的具体类型,类型断言表达的两种方式:

第一种:尖括号方式的语法

let someValue: any = 'this is a string'
let strLength: number = (<string>someValue).length

另一种:

let strLength: number = (someValue as string).length

变量声明

var

let

const

解构

数组

let a = [1, 2]
let [first, second] = a

console.log(first) // 1
console.log(second) // 2

对象

let o = {
    a: 1,
    b: 2,
    c: 3        
}
let {a, b} = o

属性重命名

let {a: newA, b:newB} = o

默认值

let o = {a: 1}
let {a, b = 100} = o

展开

数组

let a = [1, 2]
let b = [0, ...a] // [0, 1, 2]

对象

let o = {a: 1, b: 2, c: 3}
let p = {a: 2, ...o} // {a: 2, b: 2, c: 3}

接口

函数

泛型

类型推断

高级类型