TypeScript 类型

ES6的数据类型

• Boolean
• Number
• String
• Array
• Function
• Object
• Symbol
• undefined
• null

TypeScript新加的数据类型

• void
• any
• never
• 元组
• 枚举
• 高级类型

1，数组

//数组 两种等价声明
let arr1:number[] = [1,2,3]
let arr2:Array<number> = [1,2,3]

2，元组

//元组 //是一种特殊的数组，限定了数组的类型和个数
let tuple: [number,string]=[0,'1']
//为元组添加一个新的元素会怎样？允许添加
tuple.push(2)
console.log(tuple)
tuple[2]   // 但是不能访问 //tuple type '[number, string]' of length '2' has no element at index '2'.

所以非常不推荐通过push往元组里加元素。

3，函数类型

//通常返回值的类型是可以省略的，可以看到返回值的类型仍然是number
let add=(x:number,y:number)=>x+y 
//定义一种函数类型compute,没有具体实现
let compute:(x:number, y:number) =>number
compute=(a,b)=>a+b

4，对象类型

//对象
let obj:object = {x:1, y:2}
//obj.x=3; //不能赋值，因为object类型
let obj2:{x:number,y:number} = {x:1, y:2}
obj2.x=3 //可以

5，Symbol类型

Symbol的含义是具有唯一的值。

//symbol 
let s1: symbol=Symbol()
let s2=Symbol()
console.log(s1==s2) //false

 6，不能把其他类型赋值给undefined和null

//undefined ,null
let un :undefined = undefined
let nu: null = null
// un = 1 //声明了undefined，就不能赋值为其他任何类型
let num2: number = 123
 num2 = undefined //不能将类型“undefined”分配给类型“number”。
 num2=null //不能将类型“null”分配给类型“number”。

TS中undefined和null是任何类型的子类型。

可以通过改配置把"strictNullChecks": false, 设置为false。

允许把undefined和null赋值给其他类型的值。

 7,void

JS中void是一种运算符，可以让任何表达式返回undefined.

void 运算符 对给定的表达式进行求值，然后返回 undefined。

void运算符通常只用于获取undefined的原始值，一般使用void(0)，等同于void 0。

 8,never类型

永远不会有返回值的类型

 //never
 let error=()=>{
     throw new Error('error')
 }

 let endless=()=>{
     while(true){}
 }

 9，枚举类型

enum Role{
    Reporter =1,
    Developer,
    Maintainer,
    Owner,
    Guest
}

实现原理：反向映射

"use strict";
var Role;
(function (Role) {
    Role[Role["Reporter"] = 1] = "Reporter";
    Role[Role["Developer"] = 2] = "Developer";
    Role[Role["Maintainer"] = 3] = "Maintainer";
    Role[Role["Owner"] = 4] = "Owner";
    Role[Role["Guest"] = 5] = "Guest";
})(Role || (Role = {}));

枚举分类：

常量枚举（编译时计算出结果，在运行时以产量出现）

Computed枚举：非常量表达式

enum Char{
    //const 编译时算出结果
    a,
    b = Char.a,
    c=1+3,
    //computed 运行时才会计算
    d=Math.random(),
    e='123'.length
}

可以看到得到的js

"use strict";
var Char;
(function (Char) {
    //const 编译时算出结果
    Char[Char["a"] = 0] = "a";
    Char[Char["b"] = 0] = "b";
    Char[Char["c"] = 4] = "c";
    //computed 运行时才会计算
    Char[Char["d"] = Math.random()] = "d";
    Char[Char["e"] = '123'.length] = "e";
})(Char || (Char = {}));

常亮枚举（用const声明的枚举）会在编译阶段被移除。不需要对象，只需要对象的值的时候用常量枚举，可以减少编译后的代码。

const enum Month{
    Jan,
    Feb,
    Mar
}

let month =[Month.Jan, Month.Feb, Month.Mar]

编译后的js

"use strict";
let month = [0 /* Jan */, 1 /* Feb */, 2 /* Mar */];