返回专栏
· 18 分钟阅读

JavaScript 与 TypeScript 的区别


一、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

需要注意几个细节:

  1. TypeScript 编译器可以执行类型检查和 JavaScript 转译。
  2. tsc 默认情况下可以在报告部分类型错误后仍然生成 JavaScript,具体取决于构建配置。
  3. 开发者可以通过 noEmitOnError 等配置控制是否在存在错误时输出文件。
  4. 现代工具链也可以使用 esbuild、SWC、Babel 等工具转译 TypeScript,但这些工具不一定负责完整的 TypeScript 类型检查。
  5. 类型检查与代码转译是两个不同的职责,不能认为只要代码成功转译就一定通过了类型检查。

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