一、JavaScript 与 TypeScript 是什么?
JavaScript(简称 JS)是一种广泛应用于 Web 前端、服务端和跨平台开发的动态类型编程语言。它可以直接在浏览器中运行,也可以借助 Node.js、Deno、Bun 等运行时执行服务端程序。
TypeScript(简称 TS)是微软开发并维护的开源编程语言。它是 JavaScript 的超集,在 JavaScript 语法基础上增加了静态类型系统、接口、类型别名、泛型等能力。
TypeScript 的核心设计目标不是创造一个全新的运行时,而是在 JavaScript 的基础上提供更完善的静态分析能力。
1. JavaScript 的特点
- 动态类型:变量可以在运行过程中保存不同类型的数据。
- 灵活性高:无需预先声明变量类型。
- 直接运行:浏览器和 JavaScript 运行时可以直接执行 JavaScript。
- 生态成熟:拥有丰富的框架、库和开发工具。
- 运行时类型检查:许多类型错误只有在代码执行到相关位置时才会暴露。
示例:
let value = 100;
value = "Hello";
value = true;
console.log(value);
JavaScript 允许变量在不同时间保存不同类型的数据。
2. TypeScript 的特点
- 静态类型检查:可以在编译阶段发现大量类型错误。
- 类型推断:能够根据变量初始值和上下文推断类型。
- 接口与类型别名:支持描述对象结构和复杂类型关系。
- 泛型支持:能够构建具有类型约束的通用组件。
- JavaScript 兼容性:现有 JavaScript 代码通常可以逐步迁移到 TypeScript。
示例:
let value: number = 100;
value = 200;
// 编译阶段报错
// value = "Hello";
TypeScript 能够在开发和构建阶段发现赋值类型不匹配的问题。
二、JavaScript 与 TypeScript 的核心区别
两者最大的区别在于类型系统和开发阶段的检查能力,而不是最终运行时的执行机制。
| 对比维度 | JavaScript | TypeScript |
|---|---|---|
| 语言定位 | 动态类型语言 | 带有静态类型系统的 JavaScript 超集 |
| 类型声明 | 通常不需要 | 支持显式声明 |
| 类型检查 | 主要发生在运行时 | 主要发生在编译或静态检查阶段 |
| 类型推断 | 运行时确定值的类型 | 开发阶段推断静态类型 |
| 接口 | 没有原生 TypeScript 式接口 | 支持 interface |
| 类型别名 | 不支持静态类型别名 | 支持 type |
| 泛型 | 没有静态泛型系统 | 支持泛型 |
| 编译过程 | 通常直接执行,也可经过构建 | 通常需要转译或由工具链处理 |
| 运行环境 | 浏览器、Node.js 等 | 编译后的 JavaScript 运行环境 |
| 开发体验 | 灵活,类型约束较少 | 类型提示、重构和静态分析能力更强 |
| 学习成本 | 相对较低 | 需要理解类型系统 |
| 典型应用 | 脚本、小型项目、Web 应用 | 中大型项目、复杂业务系统、团队协作 |
需要注意:TypeScript 并不会在运行时自动替代 JavaScript。绝大多数情况下,TypeScript 源代码最终会被转换为 JavaScript,再交给 JavaScript 运行时执行。
三、类型系统的区别
类型系统是 JavaScript 与 TypeScript 最重要的区别。
1. JavaScript:动态类型
JavaScript 采用动态类型机制。
变量本身没有固定的静态类型约束,具体值在运行时才具有对应的类型。
let data = 100;
console.log(typeof data); // number
data = "Hello";
console.log(typeof data); // string
data = {
name: "Alice"
};
console.log(typeof data); // object
JavaScript 不要求变量声明时指定类型。
这种方式带来了较高的灵活性,但也意味着某些错误只能在运行过程中发现。
例如:
function calculateTotal(price, quantity) {
return price * quantity;
}
console.log(calculateTotal(100, 3)); // 300
console.log(calculateTotal("100", 3)); // 300
console.log(calculateTotal("Hello", 3)); // NaN
JavaScript 的乘法运算会尝试进行数值转换。
如果输入无法转换为有效数字,结果可能是 NaN,而不是在开发阶段直接报错。
2. TypeScript:静态类型检查
TypeScript 在 JavaScript 基础上增加了静态类型系统。
开发者可以显式声明类型,也可以让编译器自动推断类型。
function calculateTotal(
price: number,
quantity: number
): number {
return price * quantity;
}
console.log(calculateTotal(100, 3));
// 类型错误
// calculateTotal("100", 3);
这里:
price: number表示价格参数必须符合number类型。quantity: number表示数量参数必须符合number类型。: number表示函数返回值的静态类型为number。
当传入字符串时,TypeScript 类型检查器会报告错误。
3. 类型推断
TypeScript 并不要求所有变量都显式声明类型。
它能够根据初始值推断变量类型。
let age = 25;
// 推断为 number
age = 30;
// 类型错误
// age = "Twenty";
也可以根据函数返回值推断类型:
function add(a: number, b: number) {
return a + b;
}
// 推断返回值为 number
const result = add(10, 20);
类型推断能够减少重复声明,让代码保持简洁。
但需要注意,类型推断是编译阶段的静态分析能力,不代表 JavaScript 运行时获得了 TypeScript 类型信息。
4. 类型擦除
TypeScript 的类型信息主要用于开发阶段的静态检查。
在常规 TypeScript 转译过程中,类型声明会被移除,不会作为 JavaScript 运行时类型系统的一部分保留。
例如:
interface User {
id: number;
name: string;
}
function getUser(user: User): string {
return user.name;
}
const user: User = {
id: 1,
name: "Alice"
};
console.log(getUser(user));
经过转译后,核心 JavaScript 代码类似于:
function getUser(user) {
return user.name;
}
const user = {
id: 1,
name: "Alice"
};
console.log(getUser(user));
interface、参数类型和返回值类型都不会出现在最终 JavaScript 代码中。
这意味着 TypeScript 类型系统通常无法在运行时直接验证外部数据。
例如,从 HTTP 接口获取的 JSON 数据,即使开发者声明了 TypeScript 类型,也不能保证实际数据符合该类型。
四、接口与类型定义的区别
JavaScript 本身没有 TypeScript 的静态接口和类型别名机制。
TypeScript 可以通过 interface 和 type 描述数据结构。
1. JavaScript:通过对象约定数据结构
function printUser(user) {
console.log(user.id);
console.log(user.name);
}
const user = {
id: 1,
name: "Alice"
};
printUser(user);
JavaScript 不会在调用前静态检查 user 是否具有 id 和 name 属性。
如果传入的数据缺少属性,可能在运行时产生异常或得到 undefined。
2. TypeScript:使用 interface
interface User {
id: number;
name: string;
email?: string;
}
function printUser(user: User): void {
console.log(user.id);
console.log(user.name);
}
const user: User = {
id: 1,
name: "Alice"
};
printUser(user);
这里:
id是必需属性。name是必需属性。email?是可选属性。void表示函数不返回有意义的值。
TypeScript 会在静态检查阶段验证对象是否满足接口结构。
3. TypeScript:使用 type
type 可以定义对象类型,也可以表达联合类型、交叉类型、函数类型等。
type User = {
id: number;
name: string;
};
type Status = "pending" | "success" | "failed";
type UserId = number | string;
interface 与 type 有重叠的能力,但并不完全相同。
| 对比维度 | interface | type |
|---|---|---|
| 对象结构 | 支持 | 支持 |
| 联合类型 | 不直接支持 | 支持 |
| 交叉类型 | 可通过继承组合 | 支持 |
| 声明合并 | 支持 | 不支持重复声明合并 |
| 类实现 | 可以使用 implements |
对象结构类型也可以用于 implements |
| 适用场景 | 对象契约、可扩展接口 | 联合类型、复杂类型组合、类型别名 |
例如,接口可以通过继承扩展:
interface User {
id: number;
}
interface Admin extends User {
permissions: string[];
}
类型别名可以使用交叉类型组合:
type User = {
id: number;
};
type Admin = User & {
permissions: string[];
};
工程实践中,可以使用 interface 描述可扩展的对象契约,使用 type 表达联合类型和复杂类型组合。这是一种常见约定,并不是强制规则。
五、函数定义的区别
JavaScript 与 TypeScript 都支持函数、箭头函数、闭包和高阶函数,但 TypeScript 可以进一步约束参数和返回值。
1. JavaScript 函数
function greet(name) {
return "Hello, " + name;
}
console.log(greet("Alice"));
JavaScript 不会在定义阶段约束 name 的类型。
2. TypeScript 函数
function greet(name: string): string {
return "Hello, " + name;
}
console.log(greet("Alice"));
TypeScript 可以检查参数和返回值的类型。
3. 函数类型
TypeScript 可以单独定义函数签名:
type Calculator = (
a: number,
b: number
) => number;
const add: Calculator = (a, b) => {
return a + b;
};
这样可以确保赋值给 Calculator 的函数符合约定。
4. 可选参数与默认参数
function createUser(
name: string,
age?: number
): void {
console.log(name, age);
}
createUser("Alice");
createUser("Bob", 25);
其中:
age?: number表示参数可以省略。- 默认参数可以通过
age = 18设置。 - 可选参数与默认参数是不同的语法概念,但都能允许调用时省略参数。
5. 函数重载
TypeScript 支持函数重载声明,可以根据参数形式描述不同的调用方式。
function format(value: string): string;
function format(value: number): string;
function format(value: string | number): string {
return String(value);
}
format("Hello");
format(100);
这里的重载签名用于静态类型检查,真正执行的仍然是一个 JavaScript 函数实现。
JavaScript 没有 TypeScript 这种静态函数重载签名机制,通常通过参数判断实现类似行为。
六、泛型能力的区别
泛型是 TypeScript 类型系统的重要组成部分。
它允许开发者编写可复用的类型逻辑,同时保留输入和输出之间的类型关系。
JavaScript 可以通过函数和对象实现通用逻辑,但没有原生的静态泛型类型参数机制。
1. JavaScript 通用函数
function identity(value) {
return value;
}
const a = identity(100);
const b = identity("Hello");
JavaScript 可以处理不同类型的数据,但无法在静态阶段描述输入类型与返回类型之间的约束关系。
2. TypeScript 泛型函数
function identity<T>(value: T): T {
return value;
}
const a = identity<number>(100);
const b = identity<string>("Hello");
这里:
T是类型参数。- 输入参数使用类型
T。 - 返回值也使用类型
T。 - 调用时可以显式指定类型参数,也可以由编译器推断。
泛型能够在复用代码的同时保留类型信息。
3. 泛型约束
interface HasLength {
length: number;
}
function printLength<T extends HasLength>(
value: T
): number {
return value.length;
}
printLength("Hello");
printLength([1, 2, 3]);
// 类型错误
// printLength(100);
extends 在这里表示泛型约束。
只有具有 length 属性的类型才能满足该约束。
七、编译与运行机制的区别
这是理解 JavaScript 与 TypeScript 时非常重要的一点。
JavaScript 通常可以直接交给 JavaScript 运行时执行,而 TypeScript 通常需要先经过类型检查和转译。
1. JavaScript 执行流程
flowchart TD
A["JavaScript 源代码"] --> B["JavaScript 运行时"]
B --> C["解析与执行"]
C --> D["运行结果"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
JavaScript 运行时负责解析、执行代码,并根据具体实现采用解释执行、JIT 编译等技术。
2. TypeScript 编译流程
flowchart TD
A["TypeScript 源代码"] --> B["语法解析"]
B --> C["构建类型信息"]
C --> D["静态类型检查"]
D --> E{"是否存在阻断构建的错误"}
E -->|"是"| F["报告类型错误"]
E -->|"否"| G["转译为 JavaScript"]
G --> H["JavaScript 运行时"]
H --> I["程序执行"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
style F fill:#FBE9E9,stroke:#D9AAAA,color:#334155
style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style I fill:#FFF5DE,stroke:#E8D29A,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
需要注意几个细节:
- TypeScript 编译器可以执行类型检查和 JavaScript 转译。
tsc默认情况下可以在报告部分类型错误后仍然生成 JavaScript,具体取决于构建配置。- 开发者可以通过
noEmitOnError等配置控制是否在存在错误时输出文件。 - 现代工具链也可以使用 esbuild、SWC、Babel 等工具转译 TypeScript,但这些工具不一定负责完整的 TypeScript 类型检查。
- 类型检查与代码转译是两个不同的职责,不能认为只要代码成功转译就一定通过了类型检查。
3. TypeScript 不需要独立运行时
TypeScript 最终通常运行在 JavaScript 运行时中。
例如:
const message: string = "Hello TypeScript";
console.log(message);
转译后:
const message = "Hello TypeScript";
console.log(message);
浏览器并不需要理解 string 这种 TypeScript 类型声明。
需要补充的是,部分工具链支持直接执行或加载 TypeScript 文件,但其内部仍然需要处理 TypeScript 语法。部分新版本 TypeScript 还支持可保留的运行时语法特性,因此不能简单地将所有 TypeScript 语法都理解为纯类型声明。
八、类型安全与运行时验证
TypeScript 能够提高开发阶段的类型安全性,但它并不能保证所有运行时数据都是正确的。
这是实际工程中非常容易出现的误区。
1. TypeScript 类型不会自动验证外部数据
例如:
interface User {
id: number;
name: string;
}
async function getUser(): Promise<User> {
const response = await fetch("/api/user");
return response.json();
}
这段代码声明返回值为 Promise<User>,但服务器实际返回的数据不一定符合 User 的结构。
response.json() 得到的是运行时数据,TypeScript 的类型声明不会自动检查其字段。
因此,下面的情况仍然可能发生:
id实际上是字符串。name字段不存在。- 服务端返回了错误的数据结构。
- API 返回了
null或其他非预期值。
2. 使用运行时验证
可以使用 Zod 等运行时校验库验证外部数据。
import { z } from "zod";
const UserSchema = z.object({
id: z.number(),
name: z.string()
});
type User = z.infer<typeof UserSchema>;
async function getUser(): Promise<User> {
const response = await fetch("/api/user");
const data: unknown = await response.json();
return UserSchema.parse(data);
}
这里的关键在于:
unknown表示尚未确认类型的数据。UserSchema.parse()在运行时验证实际数据。- 验证成功后,数据才符合预期结构。
- 验证失败时,会抛出异常。
TypeScript 负责静态类型检查,运行时验证负责检查真实数据,两者解决的是不同层面的问题。
3. 静态检查与运行时验证的协作
flowchart TD
A["接收外部数据"] --> B["标记为 unknown"]
B --> C["运行时数据校验"]
C --> D{"数据是否符合结构"}
D -->|"否"| E["返回验证错误"]
D -->|"是"| F["获得可信类型数据"]
F --> G["执行业务逻辑"]
G --> H["TypeScript 静态类型检查"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#FBE9E9,stroke:#D9AAAA,color:#334155
style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style H fill:#E5F4EC,stroke:#A3CBB5,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px