在 JavaScript 开发中,我们通常不需要提前声明变量的类型。一个变量可以先存储字符串,之后又存储数字,这种灵活性让 JavaScript 使用起来非常方便,但也带来了一个问题:很多类型错误只有在代码运行时才会被发现。
例如:
let age = 18;
age = '十八';
console.log(age.toFixed(2));这段代码在 JavaScript 中可以正常执行到赋值操作,但最后调用 toFixed() 时会产生运行时错误,因为字符串并没有这个方法。
TypeScript 正是为了解决这类问题而出现的。
TypeScript 在 JavaScript 的基础上增加了静态类型系统,让我们可以在编写代码时就描述变量、函数和对象应该具备什么样的类型,并通过编译器提前发现潜在错误。
那么,TypeScript 的类型系统究竟是什么?它又提供了哪些类型?
本文将从最基础的类型开始,逐步介绍 TypeScript 类型系统中的核心知识。
一、TypeScript 的基本类型
TypeScript 继承了 JavaScript 的类型设计,同时在此基础上扩展了自己的类型系统。
JavaScript 中常见的八种数据类型如下:
这八种类型构成了 TypeScript 类型系统的基础。
需要注意的是,TypeScript 中的基本类型通常使用小写形式,例如 string、number 和 boolean。
不要把它们和首字母大写的 String、Number、Boolean 混淆,后者涉及 JavaScript 中的包装对象,后面会详细介绍。
1. boolean:布尔类型
boolean 类型只有两个可能的值:
true:表示真。false:表示假。
let isLogin: boolean = true;
isLogin = false;
// 报错:不能将字符串赋值给 boolean 类型
// isLogin = 'yes';在实际开发中,布尔类型经常用于表示状态,例如:
let isLoading: boolean = false;
let isEnabled: boolean = true;
let hasPermission: boolean = false;2. string:字符串类型
string 类型用于表示字符串。
let username: string = 'Tom';
let message: string = `Hello, ${username}`;无论是普通字符串,还是使用反引号定义的模板字符串,都属于 string 类型。
3. number:数字类型
number 类型用于表示数字,包括整数和浮点数。
let age: number = 18;
let price: number = 99.99;
let hexadecimal: number = 0xff;JavaScript 中并没有单独的整数类型和浮点数类型,它们都属于 number。
因此,下面的代码是合法的:
let count: number = 10;
count = 10.5;4. bigint:大整数类型
bigint 是 JavaScript 后来引入的一种数据类型,主要用于表示超出 number 安全整数范围的大整数。
let bigNumber: bigint = 12345678901234567890n;number 类型的安全整数范围是:
Number.MAX_SAFE_INTEGER;
// 9007199254740991当数字超过这个范围时,使用 number 可能无法保证整数运算的精确性,这时可以考虑使用 bigint。
需要注意,bigint 和 number 是两种不同的类型,不能直接混合运算:
let a: number = 100;
let b: bigint = 200n;
// 报错:number 和 bigint 不能直接相加
// let result = a + b;如果需要进行运算,必须先进行适当的类型转换。
另外,bigint 是 ES2020 引入的特性,项目的 TypeScript 编译目标需要支持 ES2020 或更高版本。
5. symbol:唯一标识符类型
symbol 用于创建唯一的标识符。
const id1: symbol = Symbol('id');
const id2: symbol = Symbol('id');
console.log(id1 === id2); // false即使两个 Symbol 使用相同的描述信息,它们仍然是两个不同的值。
Symbol 常用于对象属性命名,避免属性名称发生冲突。
const key = Symbol('key');
const user = {
[key]: 'Tom'
};
console.log(user[key]); // Tom6. object:对象类型
object 用于表示非原始类型的对象,包括:
普通对象
数组
函数
let user: object = {
name: 'Tom'
};
let numbers: object = [1, 2, 3];
let handler: object = (value: number) => {
return value * 2;
};但是,字符串、数字和布尔值等原始类型不能赋值给 object。
let value: object;
// 以下赋值都会报错
// value = 'hello';
// value = 123;
// value = true;需要注意,object 只能说明一个值属于对象类型,并不能直接描述对象内部有哪些属性。要描述具体的对象结构,需要使用对象类型定义。
7. undefined 和 null
undefined 和 null 都是 JavaScript 中表示空缺状态的特殊值,但它们表达的含义有所不同。
undefined:表示尚未定义或没有赋值。
let username: undefined = undefined;null:表示明确的空值。
let user: null = null;可以简单理解为:
undefined:还没有值。null:明确表示没有值。
这两种类型在 TypeScript 中都有各自独立的类型定义。
不过,它们能否赋值给其他类型,还与 TypeScript 的编译配置有关,后面会重点介绍。
二、包装对象类型:String 和 string 有什么区别?
这是 TypeScript 初学者比较容易混淆的知识点。
在 JavaScript 中,字符串、数字、布尔值等属于原始类型。
例如:
const name = 'Tom';
console.log(name.toUpperCase());这里的 name 是一个原始字符串,但为什么它可以调用 toUpperCase() 方法?
因为 JavaScript 提供了包装对象机制。
当我们访问原始类型的属性或方法时,JavaScript 会在必要时临时创建对应的包装对象,让我们可以像操作对象一样使用这些方法。
以字符串为例:
const str1 = 'hello';
const str2 = new String('hello');
console.log(typeof str1); // string
console.log(typeof str2); // object两者虽然都表示字符串内容,但本质上并不一样:
str1是原始字符串。str2是 String 包装对象。
TypeScript 为这些类型提供了大小写不同的写法:
例如:
const str1: string = 'hello';
const str2: String = 'hello';
const str3: String = new String('hello');
// 报错:包装对象不能赋值给小写 string
// const str4: string = new String('hello');这里需要记住一个重要结论:
实际开发中,应该优先使用小写的原始类型,不要随意使用大写的包装对象类型。
原因是:
小写类型更加符合日常开发中的实际使用场景。
大写类型可能包含包装对象,类型范围更宽。
TypeScript 中很多内置 API 的参数使用的是小写类型。
因此,声明字符串时使用 string,声明数字时使用 number,声明布尔值时使用 boolean。
三、Object 和 object 有什么区别?
除了 String 和 string,TypeScript 中还有一组非常容易混淆的类型:
Object 和 object。
它们看起来只是大小写不同,但表示的范围有明显区别。
1. Object:广义对象类型
大写的 Object 表示广义对象类型。
除了 null 和 undefined 之外,几乎所有 JavaScript 值都可以赋值给 Object。
let value: Object;
value = 'hello';
value = 123;
value = true;
value = {
name: 'Tom'
};
value = [1, 2, 3];也就是说,Object 并不只是我们通常理解的普通对象。
2. object:狭义对象类型
小写的 object 只表示非原始类型,包括普通对象、数组和函数。
let value: object;
value = {
name: 'Tom'
};
value = [1, 2, 3];
value = () => {
console.log('hello');
};
// 以下赋值都会报错
// value = 'hello';
// value = 123;
// value = true;通过对比可以发现:
这里还有一个容易忽略的知识点:空对象类型 {} 并不代表只能赋值一个没有属性的空对象。
例如:
let value: {};
value = 'hello';
value = 123;
value = {
name: 'Tom'
};在 TypeScript 中,{} 也允许非空的对象以及非空的原始值(开启严格空值检查时,null 和 undefined 除外)。
因此,{} 不能简单理解为一个空对象结构。
开发建议: 如果确实需要表达非原始类型,优先考虑小写的 object;如果需要描述对象内部属性,则应该使用具体的对象类型,而不是直接使用 Object、object 或 {}。
四、undefined 和 null 的特殊性
前面介绍了 undefined 和 null,但它们还有一个非常重要的知识点:是否可以赋值给其他类型?
这取决于 TypeScript 的一个编译选项:
strictNullChecks。
1. 关闭 strictNullChecks
当关闭严格空值检查时,undefined 和 null 可以赋值给其他类型。
let age: number = 18;
age = undefined;
age = null;这意味着,即使变量声明为 number,它仍然可能存储 null 或 undefined。
这种行为虽然与 JavaScript 的灵活性保持一致,但也容易引发运行时错误。
例如:
let user: object = undefined;
console.log(user.toString());由于 user 实际上是 undefined,调用 toString() 就会导致运行时错误。
2. 开启 strictNullChecks
开启严格空值检查后,null 和 undefined 将被视为独立类型。
let age: number = 18;
// 以下代码都会报错
// age = undefined;
// age = null;如果业务中确实需要允许空值,可以通过联合类型明确声明:
let age: number | null;
age = 18;
age = null;这样就能明确告诉 TypeScript:这个变量允许存储数字,也允许存储 null。
3. 如何开启?
在项目的 tsconfig.json 文件中配置:
{
"compilerOptions": {
"strictNullChecks": true
}
}如果项目使用严格模式:
{
"compilerOptions": {
"strict": true
}
}其中,strict 会启用包括 strictNullChecks 在内的一系列严格类型检查选项。
开发建议: 实际项目中建议开启严格模式,让 TypeScript 尽可能提前发现空值相关的问题。
五、值类型:让变量只能取指定的值
前面介绍的 string、number 等类型,描述的是一类值。
例如:
let username: string = 'Tom';
username = 'Jack';
username = 'Alice';只要是字符串,都可以赋值给 username。
但有时候,我们希望变量只能取某几个指定的值。
TypeScript 提供了**值类型(Literal Types)**来实现这个需求。
1. 什么是值类型?
值类型就是直接使用一个具体的值作为类型。
let username: 'Tom';
username = 'Tom';
// 报错:只能赋值为 Tom
// username = 'Jack';这里的 'Tom' 不再只是一个字符串值,而是一个具体的类型。
同样,数字和布尔值也可以作为值类型:
let status: 1;
let isEnabled: true;2. const 和 let 的类型推断
TypeScript 在进行类型推断时,会根据变量的声明方式决定类型。
const name = 'Tom';
let username = 'Tom';两者看起来很相似,但 TypeScript 推断出来的类型不同:
name的类型是'Tom'。username的类型是string。
为什么?
因为 const 声明的变量不能重新赋值,所以 TypeScript 可以确定它始终是 'Tom'。
而 let 声明的变量可以重新赋值,因此通常会将其类型推断为更宽泛的 string。
需要注意,如果 const 保存的是对象:
const user = {
name: 'Tom'
};TypeScript 推断出来的类型通常是:
{
name: string;
}而不是:
{
name: 'Tom';
}因为虽然 user 变量本身不能重新赋值,但是对象内部的属性仍然可以修改。
3. 值类型有什么实际用途?
值类型在实际开发中非常有用。
例如,定义订单状态:
type OrderStatus = 'pending' | 'paid' | 'cancelled';
let status: OrderStatus;
status = 'pending';
status = 'paid';
// 报错:不属于允许的状态
// status = 'success';这样就可以限制变量的取值范围,避免使用错误的状态值。
六、联合类型:一个变量允许多种类型
联合类型(Union Types)是 TypeScript 中非常常见的一种类型组合方式。
它使用 | 符号表示。
1. 联合类型的基本用法
假设一个变量既可以存储字符串,也可以存储数字:
let value: string | number;
value = 'hello';
value = 123;这里的:
string | number表示变量可以是 string 类型,也可以是 number 类型。
除了基本类型,联合类型也可以组合多个值类型:
type Gender = 'male' | 'female';
let gender: Gender;
gender = 'male';
gender = 'female';
// 报错
// gender = 'unknown';这样就能清晰地限制变量的取值范围。
2. 联合类型与 null
前面介绍过 strictNullChecks,开启严格空值检查后,如果变量可能为空,就可以通过联合类型明确声明:
let username: string | null;
username = 'Tom';
username = null;这种写法在实际开发中非常常见。
例如:
用户可能没有填写昵称。
数据库查询可能没有返回记录。
接口可能返回空数据。
某些配置项可能没有设置。
使用联合类型可以让这些情况更加明确。
3. 联合类型中的类型缩小
联合类型虽然灵活,但也带来了一个问题:
当一个变量可能属于多种类型时,TypeScript 不确定它当前具体是哪一种类型。
例如:
function printValue(value: string | number) {
console.log(value.toUpperCase());
}这段代码会报错。
因为 value 可能是字符串,也可能是数字,而 toUpperCase() 只有字符串才拥有。
解决办法就是使用类型缩小(Type Narrowing)。
function printValue(value: string | number) {
if (typeof value === 'string') {
console.log(value.toUpperCase());
} else {
console.log(value.toFixed(2));
}
}这里通过 typeof 判断变量的实际类型。
当进入 if 分支时,TypeScript 就知道 value 是 string;进入 else 分支时,就知道它是 number。
这就是类型缩小。
4. 联合类型的实际应用
例如,我们开发一个 HTTP 请求模块,需要根据不同的协议返回不同的默认端口:
function getPort(protocol: 'http' | 'https') {
switch (protocol) {
case 'http':
return 80;
case 'https':
return 443;
}
}
console.log(getPort('http')); // 80
console.log(getPort('https')); // 443这里通过联合类型限制协议参数,只允许传入 http 或 https。
这样既能限制参数范围,也能让代码更加清晰。
七、交叉类型:多个类型合并为一个类型
与联合类型不同,交叉类型(Intersection Types)表示多个类型必须同时满足。
交叉类型使用 & 符号。
1. 交叉类型的基本用法
例如:
type User = {
name: string;
};
type Account = {
account: string;
};现在我们希望定义一个同时拥有用户信息和账户信息的类型,可以使用交叉类型:
type UserAccount = User & Account;相当于:
type UserAccount = {
name: string;
account: string;
};使用时:
const user: UserAccount = {
name: 'Tom',
account: 'tom123'
};这里的 UserAccount 必须同时满足 User 和 Account 两种类型。
2. 交叉类型的实际应用
假设一个系统中存在基础用户信息:
type BaseUser = {
id: number;
username: string;
};现在需要扩展管理员信息:
type Admin = BaseUser & {
role: string;
permissions: string[];
};这样就不需要重复定义基础用户属性。
const admin: Admin = {
id: 1,
username: 'admin',
role: 'administrator',
permissions: ['user:read', 'user:write']
};这种方式在项目中非常常见,尤其适合扩展已有的对象类型。
3. 联合类型和交叉类型的区别
这两个类型很容易混淆,可以通过下面的表格理解:
记忆方法:
A | B:A 或者 B。A & B:A 和 B 都要满足。
另外,如果交叉类型中的两个基本类型互相冲突,例如:
type Impossible = string & number;那么这个类型实际上无法拥有任何有效值,可以理解为 never 类型。
八、type:定义类型别名
在前面的示例中,我们多次使用了 type。
那么,type 究竟是什么?
type 是 TypeScript 提供的类型别名定义方式。
它可以为已有类型定义一个新的名字。
1. 基本用法
type Age = number;
let age: Age = 18;这里的 Age 就是 number 的类型别名。
使用 Age 和直接使用 number 的效果是一样的。
2. 使用 type 定义复杂类型
例如:
type User = {
id: number;
username: string;
age: number;
};
const user: User = {
id: 1,
username: 'Tom',
age: 18
};这样就可以把对象结构抽取出来,方便多个地方重复使用。
3. type 支持联合类型
type Status = 'success' | 'error' | 'loading';
let status: Status;
status = 'success';
status = 'loading';4. type 支持交叉类型
type User = {
name: string;
};
type Account = {
account: string;
};
type UserInfo = User & Account;5. type 支持模板字符串类型
type World = 'world';
type Greeting = `hello ${World}`;这里的 Greeting 类型实际上就是:
type Greeting = 'hello world';6. type 的一些特点
需要注意以下几点:
类型别名不能重复声明。
类型别名具有块级作用域。
类型别名可以引用其他类型别名。
类型别名属于 TypeScript 的类型信息,不会保留到最终生成的 JavaScript 代码中。
例如:
type UserId = number;
let userId: UserId = 100;编译成 JavaScript 后,UserId 这个类型别名会被删除,只保留实际的变量和运行时代码。
九、typeof:获取变量的类型
typeof 在 JavaScript 和 TypeScript 中都有使用,但两者的作用并不完全相同。
1. JavaScript 中的 typeof
在 JavaScript 中,typeof 用于获取一个值的运行时类型,返回的是字符串。
console.log(typeof 'hello'); // string
console.log(typeof 123); // number
console.log(typeof true); // boolean
console.log(typeof undefined); // undefined
console.log(typeof {}); // object它的主要作用是帮助我们判断一个值在运行时属于什么类型。
2. TypeScript 中的 typeof
TypeScript 在原有 typeof 的基础上增加了类型层面的用法。
它可以获取一个变量的类型,并将结果用于类型定义。
const user = {
id: 1,
username: 'Tom',
age: 18
};
type User = typeof user;此时,User 类型相当于:
type User = {
id: number;
username: string;
age: number;
};这样就不需要手动重复编写对象类型。
3. typeof 获取对象属性类型
const config = {
port: 8080,
host: 'localhost'
};
type Config = typeof config;
type Port = typeof config.port;其中:
Config表示整个对象的类型。Port表示config.port属性的类型,也就是number。
4. typeof 的实际应用
假设项目中已经定义了一份配置:
const defaultConfig = {
timeout: 5000,
retry: 3,
baseURL: 'https://api.example.com'
};如果其他地方还需要使用这份配置对应的类型,就可以直接使用:
type Config = typeof defaultConfig;
function request(config: Config) {
console.log(config.baseURL);
}这样可以避免类型定义和实际配置出现不一致的问题。
需要注意,TypeScript 中的类型查询 typeof 是编译时行为,而 JavaScript 中的 typeof 是运行时运算符。
两者虽然使用相同的关键字,但应用场景不同。
十、总结
本文介绍了 TypeScript 类型系统中的一系列基础知识。
我们可以把这些知识归纳为以下几个方面:
学习 TypeScript 时,不建议只记住各种类型的语法,更重要的是理解它们解决了什么问题。
例如:
想限制变量只能存储字符串,使用
string。想让变量支持字符串或数字,使用
string | number。想让对象同时拥有多个类型的属性,使用
&。想复用已有类型,使用
type。想根据已有变量推导类型,使用
typeof。想避免空值引发运行时错误,开启
strictNullChecks。
TypeScript 类型系统的核心价值,是通过类型约束让代码更加明确、可靠和易于维护。
掌握这些基础知识之后,再继续学习数组类型、对象类型、函数类型、泛型和类型推断,就会容易很多。