基础类型

• 布尔值

let isDone: boolean = false

• 数字

和 JavaScript 一样，TS里所有数字都是浮点数，类型是 number。除了支持十进制和十六进制字面量，还支持二进制和八进制字面量。

let decLiteral: number = 6
let hexLiteral: number = 0xf00d
let binaryLiteral: number = 0b1010
let octalLiteral: number = 0o744

• 字符串

let name: string = "bob"

还可以使用模版字符串，它可以定义多行文本和内嵌表达式。这种字符串是被反引号包围，并且以${ expr }这种形式嵌入表达式

let name: string = `Gene`
let sentence: string = `Hello, my name is ${ name }`

• 数组

有两种方法定义数组。第一种，在元素上面接上[]，表示由此类型元素组成一个数组：

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

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

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

• 元祖 Tuple

元祖类型允许表示一个已知元素数量和类型的数组，各元素类型不必相同。比如，你可以定义一对值分别为string和number类型的元祖

// Declare a tuple type
let x: [string, number]
// Initialize it
x = ['hello', 10] // OK
// Initialize it incorrectly
x = [10, 'hello'] // Error

• 枚举

默认情况下从0开始为元素编号

enum Color {Red, Green, Blue}
let c: Color = Color.Green

我们也可以手动为元素编号

enum Color {Red = 1, Green, Blue}
let colorName: string = Color[2]

console.log(colorName)  // 显示'Green'因为上面代码里它的值是2

• Any

当我们想要为那些在编程阶段还不清楚类型的变量指定一个类型，可以使用any类型来标记这些变量

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

在对现有代码进行改写的时候，any类型是十分有用的，可以在上面调用任意的方法

let notSure: any = 4
notSure.ifItExists() // okay, ifItExists might exist at runtime
notSure.toFixed() // okay, toFixed exists (but the compiler doesn't check)

当你只知道一部分数据的类型时，any类型也是有用的。 比如，你有一个数组，它包含了不同的类型的数据

let list: any[] = [1, true, "free"]

list[1] = 100

• Void

某种程度上来说，void类型与any类型相反，它表示没有任何类型。当一个函数没有返回值的时候，你通常会见到其返回值类型是void

function warnUser(): void {
    console.log("This is my warning message")
}

声明一个void类型的变量没有什么大用，因为你只能赋予undefined和null

• Null 和 Undefined

默认情况下，undefined和null是所有类型的子类型

• Never

never类型表示的是那些用不存在值的类型，never是任何类型的子类型

• Object

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

变量声明

• 参考我的另一篇文章：ES 6 的声明方式
• 解构

数组解构赋值

let input = [1, 2]
let [first, second] = input
console.log(first) // outputs 1
console.log(second) // outputs 2

以上代码使用索引

first = input[0]
second = input[1]

用于已声名的变量：

// swap variables
[first, second] = [second, first]

作用于函数

let input = [1, 2]
function f([first, second]: [number, number]) {
    console.log(first)
    console.log(second)
}
f(input)

在数组中使用...语法创建剩余变量

let [first, ...rest] = [1, 2, 3, 4]
console.log(first) // outputs 1
console.log(rest) // outputs [ 2, 3, 4 ]

当然，也可以忽略尾随元素

let [first] = [1, 2, 3, 4]
console.log(first) // outputs 1

• 对象解构

let o = {
    a: "foo",
    b: 12,
    c: "bar"
}
let { a, b } = o

上面代码通过o.a和o.b创建了a和b
可以在对象里使用...语法创建剩余变量

let { a, ...passthrough } = o
let total = passthrough.b + passthrough.c.length

• 属性命名

let { a: newName1, b: newName2 } = o

方向从左至右，可以像以下代码一样理解

let newName1 = o.a
let newName2 = o.b

需要注意的是这里，这里冒号不是指示类型。如果想要指定类型，仍需在后面写上完整的模式

let {a, b}: {a: string, b: number} = o

• 展开
  展开操作符与解构相反

let first = [1, 2]
let second = [3, 4]
let bothPlus = [0, ...first, ...second, 5]

上面代码令bothPlus的值为[0,1,2,3,4,5]。展开操作创建了first和second的一份浅拷贝，不会被展开操作所改变。
不建议展开对象

接口

TypeScript的核心原则之一是对所具有的结构进行类型检查。
在TypeScript里，接口的作用就是为了这些类型命名和为你的代码或第三方代码订立契约。
接口是如何工作的：

function printLabel(labelledObj: { label: string }) {
  console.log(labelledObj.label)
}

let myObj = { size: 10, label: "Size 10 Object" }
printLabel(myObj);

类型检查器会查看printLabel的调用。printLabel有一个参数，并要求这个对象参数有一个名为label类型为string的属性。需要注意的是，我们传入的对象参数实际上会包含很多属性，但是编译器只会检查那些必须的属性是否存在，并且其类型是否匹配。
下面用接口描述上面的例子（必须包含一个label属性且类型为string）：

interface LabelledValue {
  label: string;
}

function printLabel(labelledObj: LabelledValue) {
  console.log(labelledObj.label);
}

let myObj = {size: 10, label: "Size 10 Object"};
printLabel(myObj);

LabelledValue接口就好比一个名字，用来描述上面例子里的要求。它代表了有一个label属性且类型为string的对象。在这里只关注值的外形。只要传入对象满足接口，那么它就是被允许的。
类检查器不会检查属性的顺序，只要相应的属性存在即可。

• 可选属性

接口里的属性不全都是必须的。有些是只在某些条件下存在，或者根本不存在。 可选属性在应用“option bags”模式时很常用，即给函数传入的参数对象中只有部分属性赋值了。
下面是应用了“option bags“的例子：

interface SquareConfig{
  color?: string
  width?: number
}

funcrtion createSquare(config:SquareConfig):{color: string; area: number}{
  let newSquare =  {color: "white"; area: 100}
  if(config.color){
    newSquare.color = config.color
  }
  if(config.width){
    newSquare.area = config.width * config.width
  }
  return newSquare
}
let mySquare = createSquare({color: "black"})

带有可选属性的接口与普通接口的定义差不多，只是在可选属性名字定义后面加上一个?符号
可选属性的好处之一是可以对可能存在的属性进行预定义，好处之二是可以捕获引用了不存在的属性时的错误。比如，故意将属性名字拼错，就会得到一个错误提示。

• 只读属性

一些对象属性只能在对象刚刚创建的时候修改其值。可以在属性名前用readonly来指定只读属性：

interface Point {
  readonly x: number
  readonly y: number
}

可以通过赋值一个对象字面量来构造一个Point。赋值后，x和y再也不能被改变

let p1: Point = {x:10, y: 20}
p1.x = 5 //error

TypeScript具有Readonly<T>类型，确保数组创建后再也不能被修改：

let a: number[] = [1,2,3,4]
let ro: ReadonlyArray<number> = a
ro[0] = 12 // error
ro.push(5) // error
ro.length = 100 // error
a = ro // error

上面的最后一行，就算是把整个ReadonlyArray赋值到一个普通数组也不可以。但是可以用类型断言重写：

a = ro as number[]

• 函数类型

为了使用接口表示函数类型，需要给接口定义一个调用签名。它就像是一个只有参数列表和返回值类型的函数定义。参数列表里的每个参数都需要名字和类型

interface SearchFunc {
  (source: string, subString: string): boolean;
}

下例展示了如何创建一个函数类型的变量，并将一个同类型的函数赋值给这个变量

let mySearch: SearchFunc
mySearch = function(source: string, subString: string){
  let result = source.search(subString)
  return result > -1
}

对于函数类型的类型检查来说，函数的参数名不需要与接口里定义的名字相匹配：

let mySearch: SearchFunc
mySearch = function(src: string, sub:string){
  let result = src.search(sub)
  return result > -1
}

持续更新中。。。