一、原始数据类型
布尔值
布尔值是最基础的数据类型,在 TypeScript 中,使用 boolean 定义布尔值类型
let isTrue: boolean = false;
数值
使用 number 定义数值类型
let num: number = 1;
字符串
使用 string 定义字符串类型
let name: string = "Tom";
Null 和 Undefined
可以使用 null 和 undefined 来定义这两个原始数据类型
let u: undefined = undefined;
let n: null = null;
二、任意值 any
任意值(Any)用来表示允许赋值为任意类型。
any 类型可以在赋值过程中任意改变类型
const num: number = 1;
const str: string = '1';
let param: any;
param = num;
param = str;
声明一个变量为任意值之后,对它的任何操作,返回的内容的类型都是任意值。
三、 联合类型
一个变量可以同时支持一种类型或者多种不同的类型,不同类型之间使用 |
来分割
let union: number | string
union = 1;
union = "1";
union = true; // error 出错,不能是number和string之外的其他类型
四、数组类型
在 TypeScript 中,数组类型有多种定义方式,比较灵活。
数组
最简单的方法是使用「类型 + 方括号」来表示数组:
let strArray: string[];
strArray = ['1', '2'];
数组泛型
我们也可以使用数组泛型来表示数组:
let numberArray: Array<number> = [1, 1, 2, 3, 5];
数组接口
接口也可以用来描述数组:
interface numberArray {
[index: number]: number;
}
let fibonacci: numberArray = [1, 1, 2, 3, 5];
NumberArray 表示:只要索引的类型是数字时,那么值的类型必须是数字。
虽然接口也可以用来描述数组,但是我们一般不会这么做,因为这种方式比前两种方式复杂多了。
元组(Tuple)
数组合并了相同类型的对象,而元组(Tuple)合并了不同类型的对象。
元组就是固定长度、固定类型的数组,注意一定要指明类型
let strArray: [number, string];
strArray = [1, '2'];
五、void
使用 void 来表示一个函数没有一个返回值
function log(msg: string): void {
console.log(msg);
}
六、never
一个函数永远执行不完,一般用于错误抛出
function throwError(message: string, errorCode: number): never {
throw {
message,
errorCode,
}
}
七、字面量类型
字面量类型用来约束取值只能是某几个字符串中的一个。
const a = 3
const b = 0 | 1 | 2
const c = 'a' | 'b' | 'c'
注意,类型别名与字符串字面量类型都是使用 type 进行定义。
八、枚举
枚举(Enum)类型用于取值被限定在一定范围内的场景,比如一周只能有七天,颜色限定为红绿蓝等。
enum Color {
red,
green,
blue
}
let color = Color.blue
console.log(color) // 2
enum Color {
red = "red",
green = "green",
blue = "blue"
}
let color = Color.blue
console.log(color) // "blue"
九、接口
它能合并众多类型声明至一个类型声明
interface Name {
first: string;
second: string;
}
let name: Name;
name = {
first: 'John',
second: 'Doe'
};
定义的变量比接口少了一些属性,或者多一些属性都是不允许的
name = {
// Error: 'Second is missing'
first: 'John'
};
name = {
// Error: 'Second is the wrong type'
first: 'John',
second: 1337
};
name = {
// Error: 'third' does not exist in type 'Name'
first: 'John',
second: 'Doe',
third: '1'
};
十、泛型(Generics)
泛型是指在定义函数、接口或类的时候,不预先指定具体的类型,而在使用的时候再指定类型的一种特性。
let list1: number[] = [1,2,3,4]
let list2: Array<string> = [1,2,3,4]
let lastInArray = <T>(arr: T[]) => {
return arr[arr.length - 1];
}
let l1 = lastInArray([1,2,3,4])
let l2 = lastInArray<string>(['a', 'b', 'c'])
let l3 = lastInArray<string | number>(['a', 'b', 'c'])
多个类型参数
定义泛型的时候,可以一次定义多个类型参数:
function swap<T, U>(tuple: [T, U]): [U, T] {
return [tuple[1], tuple[0]];
}
swap([7, 'seven']); // ['seven', 7]
swap<string, number>(['1', 1])
十一、类型相关
类型推论
如果没有明确的指定类型,那么 TypeScript 会依照类型推论(Type Inference)的规则推断出一个类型。
let age = "7";
// 等价于
let age: string = "7"
如果定义的时候没有赋值,不管之后有没有赋值,都会被推断成 any 类型而完全不被类型检查。
let myFavoriteNumber;
myFavoriteNumber = 'seven';
myFavoriteNumber = 7;
类型断言
类型断言(Type Assertion)可以用来手动指定一个值的类型。
值 as 类型
或者
<类型>值
在 tsx 语法(React 的 jsx 语法的 ts 版)中必须使用前者,即 值 as 类型
。
类型别名
类型别名用来给一个类型起个新名字。
type Name = string;
type NameResolver = () => string;
type NameOrResolver = Name | NameResolver;
function getName(n: NameOrResolver): Name {
if (typeof n === 'string') {
return n;
} else {
return n();
}
}
类型别名常用于联合类型。