以下内容基于 TypeScript 4.6.2 更新。所有内容都基于严格模式
。
环境与工具
构建环境
当对单个文件进行编译时,可以使用下面的命令:
# 将 ts 文件编译成 js 文件
$ tsc greeter.ts
# 运行 js 文件
$ node greeter.js
但是,对于工程来说,文件量比较大,不可能单个文件编译。需要使用类似于 Java
工程中的 Maven
或者 Gradle
管理工程。TypeScript
提供了原生的工具,配置文件:tsconfig.json
,类似 pom.xml
和 build.gradle
。
通过如下方式构建工程:
$ mkdir project_a && cd project_a
$ tsc --init
会生成 tsconfig.json
文件。
代码调试
为了直接运行 ts 代码,可以使用 ts-node
包。
# 安装 ts-node
$ npm i ts-node -g
# 运行代码
$ ts --project tsconfig.json ts/main.ts
tsconfig.json 简单配置如下:
{
"compilerOptions": {
"target": "es2015",
"module": "es2020",
"outDir": "./js/",
"rootDir": "./ts/",
"strict": true,
"esModuleInterop": true,
"skipLibCheck": true,
"forceConsistentCasingInFileNames": true
}
}
基础类型
介绍
TypeScript 支持与 JavaScript 几乎相同的数据类型,此外还提供了实用的枚举类型等。
boolean
布尔值包含:true, false。
number
number 包含浮点数和整数。同时支持十进制、十六进制、二进制、八进制。
Number 表示的最大整数为 2^53 - 1
,可以写为 Number.MAX_SAFE_INTEGER
。
let hexLiteral: number = 0xf00d; // 十六进制
let binaryLiteral: number = 0b1010; // 二进制
let octalLiteral: number = 0o744; // 八进制
bigint
是大整数类型。大于 Number 的整数可以用 bigint 表示。
let bigLiteral: bigint = 100n; // 整数后边加个 n 定义大整数
let bigObject: bigint2 = BigInt("9007199254791") // 对象方式定义,也可以不加双引号
BigInt
与 Number
的不同点:
BigInt
不能用于Math
对象中的方法。BigInt
不能和任何Number
实例混合运算,两者必须转换成同一种类型。BigInt
变量在转换为Number
变量时可能会丢失精度
string
可以使用双引号("
)或单引号('
)表示字符串。还可以使用_模版字符串_,它可以定义多行文本和内嵌表达式。 这种字符串是被反引号包围(` `),并且以 ${ expr }
这种形式嵌入表达式
let name: string = `Gene`;
let sentence: string = `Hello, my name is ${ name }.`;
Array
TypeScript像JavaScript一样可以操作数组元素。 有两种方式可以定义数组。 第一种,可以在元素类型后面接上[]
,表示由此类型元素组成的一个数组:
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
当访问一个已知索引的元素,会得到正确的类型:
console.log(x[0].substr(1)); // OK
console.log(x[1].substr(1)); // Error, 'number' does not have 'substr'
当访问一个越界的元素会报错。
x[3] = "world"; // Error, Property '3' does not exist on type '[string, number]'.
console.log(x[5].toString()); // Error, Property '5' does not exist on type '[string, number]'.
Enum
enum
类型是对JavaScript标准数据类型的一个补充。 像C#等其它语言一样,使用枚举类型可以为一组数值赋予友好的名字。
enum Color {Red, Green, Blue}
let c: Color = Color.Green;
默认情况下,从0
开始为元素编号。 你也可以手动的指定成员的数值。 例如,我们将上面的例子改成从1
开始编号:
enum Color {Red = 1, Green, Blue}
let c: Color = Color.Green;
或者,全部都采用手动赋值:
enum Color {Red = 1, Green = 2, Blue = 4}
let c: Color = Color.Green;
枚举类型提供的一个便利是你可以由枚举的值得到它的名字。 例如,我们知道数值为2,但是不确定它映射到Color里的哪个名字,我们可以查找相应的名字:
enum Color {Red = 1, Green, Blue}
let colorName: string = Color[2];
console.log(colorName); // 显示'Green'因为上面代码里它的值是2
Unknown
当我们在写应用的时候可能会需要描述一个我们还不知道其类型的变量。这些值可以来自动态内容,例如从用户获得,或者我们想在我们的 API 中接收所有可能类型的值。在这些情况下,我们想要让编译器以及未来的用户知道这个变量可以是任意类型。这个时候我们会对它使用 unknown
类型。
let notSure: unknown = 4;
notSure = "maybe a string instead";
// OK, definitely a boolean
notSure = false;
如果你有一个 unknwon
类型的变量,你可以通过进行 typeof
、比较或者更高级的类型检查来将其的类型范围缩小,这些方法会在后续章节中进一步讨论:
// @errors: 2322 2322 2322
declare const maybe: unknown;
// 'maybe' could be a string, object, boolean, undefined, or other types
const aNumber: number = maybe;
if (maybe === true) {
// TypeScript knows that maybe is a boolean now
const aBoolean: boolean = maybe;
// So, it cannot be a string
const aString: string = maybe;
}
if (typeof maybe === "string") {
// TypeScript knows that maybe is a string
const aString: string = maybe;
// So, it cannot be a boolean
const aBoolean: boolean = maybe;
}
Any
有时候,我们会想要为那些在编程阶段还不清楚类型的变量指定一个类型。 这些值可能来自于动态的内容,比如来自用户输入或第三方代码库。 这种情况下,我们不希望类型检查器对这些值进行检查而是直接让它们通过编译阶段的检查。 那么我们可以使用any
类型来标记这些变量:
let notSure: any = 4;
notSure = "maybe a string instead";
notSure = false; // okay, definitely a boolean
在对现有代码进行改写的时候,any
类型是十分有用的,它允许你在编译时可选择地包含或移除类型检查。 你可能认为Object
有相似的作用,就像它在其它语言中那样。 但是Object
类型的变量只是允许你给它赋任意值 - 但是却不能够在它上面调用任意的方法,即便它真的有这些方法:
let notSure: any = 4;
notSure.ifItExists(); // okay, ifItExists might exist at runtime
notSure.toFixed(); // okay, toFixed exists (but the compiler doesn't check)
let prettySure: Object = 4;
prettySure.toFixed(); // Error: Property 'toFixed' doesn't exist on type 'Object'.
注意:应避免使用
Object
,而是使用非原始object
类型,正如Do’s and Don’ts里所讲的那样。
当你只知道一部分数据的类型时,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
类型的变量没有什么大用,因为你只能为它赋予null
(只在--strictNullChecks
未指定时)和undefined
:
let unusable: void = undefined;
Null 和 Undefined
TypeScript里,undefined
和null
两者各自有自己的类型分别叫做undefined
和null
。 和void
相似,它们的本身的类型用处不是很大:
// Not much else we can assign to these variables!
let u: undefined = undefined;
let n: null = null;
默认情况下null
和undefined
是所有类型的子类型。 就是说你可以把null
和undefined
赋值给number
类型的变量。
然而,当你指定了--strictNullChecks
标记,null
和undefined
只能赋值给any
和它们各自的类型(有一个例外是undefined
还可以赋值给void
类型)。 这能避免_很多_常见的问题。 也许在某处你想传入一个string
或null
或undefined
,你可以使用联合类型string | null | undefined
。
联合类型是高级主题,我们会在以后的章节里讨论它。
注意:我们鼓励尽可能地使用
--strictNullChecks
,但在本手册里我们假设这个标记是关闭的。
Never
never
类型表示的是那些永不存在的值的类型。 例如,never
类型是那些总是会抛出异常或根本就不会有返回值的函数表达式或箭头函数表达式的返回值类型; 变量也可能是never
类型,当它们被永不为真的类型保护所约束时。
never
类型是任何类型的子类型,也可以赋值给任何类型;然而,_没有_类型是never
的子类型或可以赋值给never
类型(除了never
本身之外)。 即使any
也不可以赋值给never
。
下面是一些返回never
类型的函数:
// 返回never的函数必须存在无法达到的终点
function error(message: string): never {
throw new Error(message);
}
// 推断的返回值类型为never
function fail() {
return error("Something failed");
}
// 返回never的函数必须存在无法达到的终点
function infiniteLoop(): never {
while (true) {
}
}
Object
object
表示非原始类型,也就是除number
,string
,boolean
,bigint
,symbol
,null
或undefined
之外的类型。
使用object
类型,就可以更好的表示像Object.create
这样的API。例如:
declare function create(o: object | null): void;
create({ prop: 0 }); // OK
create(null); // OK
create(42); // Error
create("string"); // Error
create(false); // Error
create(undefined); // Error
类型断言
有时候你会遇到这样的情况,你会比TypeScript更了解某个值的详细信息。 通常这会发生在你清楚地知道一个实体具有比它现有类型更确切的类型。
通过_类型断言_这种方式可以告诉编译器,“相信我,我知道自己在干什么”。 类型断言好比其它语言里的类型转换,但是不进行特殊的数据检查和解构。 它没有运行时的影响,只是在编译阶段起作用。 TypeScript会假设你,程序员,已经进行了必须的检查。
类型断言有两种形式。 其一是“尖括号”语法:
let someValue: any = "this is a string";
let strLength: number = (<string>someValue).length;
另一个为as
语法:
let someValue: any = "this is a string";
let strLength: number = (someValue as string).length;
两种形式是等价的。 至于使用哪个大多数情况下是凭个人喜好;然而,当你在TypeScript里使用JSX时,只有as
语法断言是被允许的。
关于let
你可能已经注意到了,我们使用let
关键字来代替大家所熟悉的JavaScript关键字var
。 let
是ES2015引入的关键字,它比var
更加安全,因此被看做是声明变量的标准方式。 我们会在以后详细介绍它,很多常见的问题都可以通过使用let
来解决,所以尽可能地使用let
来代替var
吧。
关于 Number, String, Boolean, Symbol 和 Object
我们很容易会认为 Number
、 String
、 Boolean
、Symbol
以及 Object
这些类型和我们以上推荐的小写版本的类型是一样的。但这些类型不属于语言的基本类型,并且几乎在任何时候都不应该被用作一个类型:
// @errors: 2339
function reverse(s: String): String {
return s.split("").reverse().join("");
}
reverse("hello world");
相对地,我们应该使用 number
、string
、boolean
、object
和 symbol
function reverse(s: string): string {
return s.split("").reverse().join("");
}
reverse("hello world");
语法
泛型
泛型类指的是实例部分的类型,所以类的静态属性不能使用这个泛型类型。
类型推断
推断发生在初始化变量和成员,设置默认参数值和决定函数返回值时。
类型兼容性
TypeScript 里的类型兼容性是基于结构子类型的。
结构类型是一种只使用其成员来描述类型的方式。 它正好与名义(nominal)类型形成对比。
在基于名义类型的类型系统中,数据类型的兼容性或等价性是通过明确的声明和/或类型的名称来决定的。这与结构性类型系统不同,它是基于类型的组成结构,且不要求明确地声明。