TypeScript支持JavaScript所有的数据类型,除此以为还提供了其他的一些数据类型。TypeScript包括以下基本数据类型:

布尔类型(boolean)

布尔类型是最简单的数据类型,只包含true和false两种值。

 //注意:布尔类型不能赋予其他的值。
 let isDone : boolean = false;
 let isOpen : boolean = true ;
 let isClose : boolean = 1;//报错:[ts] Type '1' is not assignable to type 'boolean'.
 isClose = "null";//报错:[ts] Type '"null"' is not assignable to type 'boolean'.
 isClose = null ;//Ok
 isClose = undefined;//OK

数字类型(number)

和JavaScript一样,TypeScript的所有数字都是浮点数。这些浮点数的类型是number。除了支持十进制和十六进制字面量,还支持ECMAScript 2015中引入得二进制和八进制字面量。

 let decLiteral: number = 6;//10进制
 let hexLiteral: number = 0xf00d;//16进制
 let binaryLiteral: number = 0b10;//2进制
 let octalLiteral: number = 0o7412;//8进制
 console.log(hexLiteral);//61453
 console.log(binaryLiteral);//2
 console.log(octalLiteral);//3850

字符串类型(string)

字符串类型用来处理文本,和JavaScript一样,可以使用双引号(”)或者单引号(’)表示字符串。

 let name: string = "Bob";
 name = "Smith";
 name = 'Jane';

除此之外,还可以使用模板字符串,他可以定义多行文本和内嵌表达式。这种字符串是被反引号(`),并且以${ expr }这种形式嵌入表达式。

 let aName : string = Jane;
let age : number = 18;
let sentence : string = Hello ,my name is ${name}. I'll be ${ age + 1} years old next month.;

数组(array)

TypeScript可以像JavaScript一样可以操作数组元素。有两种方式定义数组:

1.在元素类型后面接上中括号([]),表示由此类型元素组成的一个数组
2.使用数组泛型,Array<元素类型>

 let list0 : number[] = [1, 2, 3, 4];
 let list1 : Array<number> = [1, 2, 3];

元组(tuple)

元组类型允许表示一个已知元素数量和类型的数组,各元素的类型不必相同。

 let xArr : [string, number];
 xArr = ['hello', 10];  //ok
 xArr = [10 , "hello"]; //error 
 //需要注意的是,哪怕在这里会报错,但是由于TS会编译成JS代码,
 //所以在运行的时候,x的值最后会被赋值为[10 , "hello"]。

当访问一个越界的数组元素时,会使用联合类型替代:

 xArr[3] = 'world';//OK, 字符串可以赋值给(string | number)类型
 console.log(xArr[4].toString());// OK, 'string' 和 'number' 都有 toString
 xArr[5] = true;// Error, 布尔不是(string | number)类型

枚举(enum)

枚举数据类型是对JavaScript标准数据类型的一个补充。像C#等其他语言一样,使用枚举类型可以为一组数值赋予友好的名字。

enum Fruit {Apple , Pear , Banana};
 let fruit : Fruit = Fruit.Pear;
 console.log(fruit);//1

默认情况下从0开始编号,你也可以显式的指定部分成员的数值,如:

 enum Color { Red = 1, Black = 2, Pink = 4, Green, Blue };
 let color : Color = Color.Green;
 console.log(color);//5

或者,全部采用显式赋值的方式:

 enum Animal {Monkey = 1, Snake = 2, Person = 4};
 let animal : Animal = Animal.Snake;

枚举类型可以方便的获得其枚举值对应的枚举名,如:

 enum Animal {Monkey = 1, Snake = 2, Person = 4};
 let animal : Animal = Animal.Snake;
 let animalName : string = Animal[2];
 console.log(animalName);//Snake

任意值类型(any)

任意值是TypeScript针对编程时类型不明确的变量时使用的一种数据类型。这些值可能来自于动态的内容,比如来自第三方输入或者第三方代码库。这种情况下,我们不希望类型检查器对这些值进行检查而是直接让它们通过编译阶段的检查,那么我们使用 any 类型来标记这些变量。

 let notSure : any = 4;
 notSure = "not sure";
 notSure = false;

Void类型(void)

从某种程度来说,void 类型和 any 正好相反,它表示没有任何类型。通常用于一个函数的返回值类型:

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

void 类型的变量只能为它赋值为undefinednull:

 let unsure : void = null;
 unsure = undefined;
 unsure = 1;//[ts] Type '1' is not assignable to type 'void'.

“Null 和 Undefined”

TypeScript里,值null和undefined 两者各自有自己的类型,分别叫做null和undefined。和void相似,它们本身的类型用处不是很大。默认情况下,null和undefined是所有类型的子类型。就是说可以把null和undefined赋值给任意的其他类型的变量。 然而,当指定了–strictNullChecks标记进行编译,null和undefined只能赋值给void和它们各自:

 let u: undefined = undefined;
 let n: null = null;
 console.log(u);//undefined
 console.log(n);//null
 let uu : undefined;
 let nn : null;
 console.log(uu);//undefined
 console.log(nn);//undefined
 u = null;
 n = undefined;
 console.log(n);//nudefined

Never类型(never)

TypeScript 2.0引入了新的原始类型nevernever类型代表从来不会出现的值的类型,特别的,never可以是永远不返回的函数的返回值类型,也可以是变量在类型收窄中不可能为真的类型。never类型有以下特征:

1.never类型是任何类型的子类型,并且可以赋值给任何类型 没有类型是never类型的子类型,或者可以赋值给never(除了never本身)

2.在一个没有返回值标注的函数表达式或箭头函数中,如果函数没有return语句,或者仅有表达式类型为never的return语句,并且函数的终点无法被执行到(按照控制流程分析),则推导出的函数表达式的返回值类型为never。

3.在一个明确指定了never返回值类型的函数中,所有return语句(如果有)表达式的值必须为类型,且函数不应能执行到终止点。

4.由于never类型是所有类型的子类型,在联合类型中它始终被忽略并且只要函数有其他返回的类型,推导出的函数返回值类型中就会忽略它。

下面是一些返回never类型的函数:

//返回never的函数必须存在无法到达的终点 
function error(message: string): never {
    throw new Error(message);
}
//推断的返回值类型为never
function fail(){
    return error("Something failed.");
}
//返回never的函数必须存在无法达到的终点
function infiniteLoop(){
    while(true){
        
    }
}

下面是一些使用返回never类型的函数:

//推断的返回值类型为number
function move1(direction : "up" | "down"){
    switch(direction){
        case "up" :
            return 1;
        case "down":
            return -1; 
    }

    return error("永远无法达到的终点")
}
//推断的返回值类型为T
function check<T> (x:T | undefined){
    return x || error("为定义的值");
}

因为never 可以赋值给任何类型,返回 never 的函数可以在回调需要返回一个具体类型的时候被使用:

function test(cb: () => string) {
    let s = cb();
    return s;
}

test(() => "hello");
test(() => fail());
test(() => { throw new Error(); });

类型断言

 

TypeScript中类型断言好比其他语言中的类型转换,但是不进行特殊的类型检查和解构。它没有运行时的影响,只在编译阶段起作用。类型断言有两种方式:

1.“尖括号”法

2.as 语法


//类型断言
let someValue : any = "This is my book!";
let strLength : number = (<string>someValue).length;
strLength = (someValue as string).length;

两种形式是等价的。 至于使用哪个大多数情况下是凭个人喜好;然而,当你在TypeScript里使用JSX时,只有 as 语法断言是被允许的。