TypeScript 7.0 RC 深度解析：编译器 Go 重写实战指南——10 倍提速背后的工程逻辑与迁移路径

前言：为什么这件事值得单独写一篇

2026年6月18日，TypeScript 团队发布了 7.0 RC。这不是一个普通的版本号跨越——编译器的核心语言从 TypeScript/JavaScript 整体迁移到了 Go，在大型 monorepo 上实现了平均 10 倍的性能提升。

但如果你只是把它理解为「更快了」，那你错过了最有趣的部分。

这次迁移是一次有组织的工程冒险：不是推翻重来，而是在保留每一个类型检查逻辑的前提下，把整个编译器「翻译」成另一种语言。它考验的不仅是 TypeScript 团队的 Go 能力，更是对自身编译器的理解深度——你能把一个 10 年积累的代码库用另一种语言重写，还能让语义完全一致，这本身就是一种技术实力的证明。

本文从程序员的实战视角出发，深度拆解这次迁移的底层逻辑、性能来源、配置断层、以及你真正需要关心的迁移路径。文章包含完整代码示例和真实 benchmark 数据，读完之后你应该能判断：这次升级对你的团队意味着什么，以及你应该在什么时间窗口动手。

一、背景：TypeScript 编译器为什么慢到需要重写

1.1 困境的根源：自举编译器的性能天花板

TypeScript 编译器（tsc）是用 TypeScript 自身编写的，这在语言发展史上很常见——Rust 编译器最初也是用 OCaml 写的，Go 编译器最初也是用 C 写的。自举（bootstrapping）让语言团队可以用自己的语言开发自己的工具链，减少了对外部工具链的依赖。

但自举也有代价。JavaScript 引擎（V8、SpiderMonkey 等）对高度 CPU 密集型任务有天然的性能上限，尤其在以下几个方面：

单线程瓶颈：JavaScript 天生是单线程的。虽然有 Web Worker 可以做并行计算，但 Worker 之间是共享内存受限的——编译器中最耗时的类型检查恰恰需要大量跨文件的共享状态，Worker 之间的数据传递开销经常抵消并行收益。

内存碎片化：V8 的 GC 在处理编译器场景时会产生大量短期对象（AST 节点、类型对象、符号表），在大型代码库中这会导致Stop-the-World GC 停顿，在 --watch 模式下尤为明显。

增量构建的先天劣势：tsc --build 和 --incremental 虽然有进步，但在处理 monorepo 中跨项目引用时，每次文件变更仍然需要重新处理大量受影响的文件，因为这些文件的类型信息分散在内存的各个角落。

1.2 团队做了什么：在天花板下的极限优化

从 5.0 到 6.0，TypeScript 团队做了大量极限优化：

• --build 模式的深度重构，减少不必要的重新检查
• isolatedDeclarations：让声明文件生成可以独立进行
• declarationMap：让 IDE 可以直接导航到 .d.ts 的源码
• noUncheckedSideEffectImports：减少无用的 side-effect import 处理

这些优化是真实有效的——但它们都是在 JavaScript 运行时的「天花板」下的工程努力。每次优化能带来 10-20% 的提升，但无法实现量级上的跃迁。

Go 重写从根本上改变了这个格局：共享内存并行、原生编译速度、无 GC 停顿——这些不是 JavaScript 运行时可以提供的特性。

二、性能解剖：10 倍提速从哪里来

2.1 编译管道的并行化重构

TypeScript 编译器的执行管道分为几个阶段：

源代码 → 解析(Parsing) → 绑定(Binding) → 类型检查(Type Checking) → 发射(Emitting)

不同阶段的并行化难度不同：

解析阶段（Parsing）：每个文件的词法分析和语法分析完全独立，是天然的数据并行问题。在 Go 中可以用 goroutine pool 并行处理数千个源文件：

// Go 重写后的解析器架构示意
func (p *Parser) ParseFiles(files []string) []*ast.SourceFile {
    results := make(chan *ast.SourceFile, len(files))
    
    // 使用 worker pool 并行解析
    g := new(errgroup.Group)
    sem := make(chan struct{}, runtime.NumCPU()) // 信号量控制并发度
    
    for _, file := range files {
        file := file // 捕获循环变量
        g.Go(func() error {
            sem <- struct{}{}
            defer func() { <-sem }()
            
            content, err := os.ReadFile(file)
            if err != nil {
                return err
            }
            
            sf := p.parseSource(file, content)
            results <- sf
            return nil
        })
    }
    
    if err := g.Wait(); err != nil {
        // 处理错误
    }
    close(results)
    
    // 收集结果
    parsed := make([]*ast.SourceFile, 0, len(files))
    for sf := range results {
        parsed = append(parsed, sf)
    }
    return parsed
}

发射阶段（Emitting）：同样是文件级别的独立操作，可以在所有类型检查完成后并行执行。

类型检查阶段（Type Checking）：这是最复杂的并行化挑战。一个文件的类型信息依赖于它导入的所有其他文件——你不能简单地把文件分给不同线程独立检查，因为存在循环依赖和交叉引用。

2.2 类型检查器的共享内存并行：工作窃取策略

TypeScript 7.0 的解决方案是固定数量的类型检查器 worker（默认为 CPU 核心数减 1）：

// Go 重写后的类型检查器架构
type TypeChecker struct {
    workers   int
    jobQueue  chan *CheckJob      // 待检查的文件队列
    resultMap sync.Map            // 检查结果映射
    
    // 每个 worker 有自己的部分世界观
    globalSymbols    map[string]*Symbol   // 共享的全局符号表
    declarationCache map[string]*Type      // 共享的声明缓存
    mu              sync.RWMutex          // 细粒度锁
}

func (tc *TypeChecker) Run(ctx context.Context, program *Program) error {
    // 将所有待检查文件加入队列
    jobs := tc.createCheckJobs(program)
    
    // 启动 worker pool
    var wg sync.WaitGroup
    for i := 0; i < tc.workers; i++ {
        wg.Add(1)
        go func(workerID int) {
            defer wg.Done()
            tc.runWorker(ctx, workerID)
        }(i)
    }
    
    wg.Wait()
    return tc.errorCount.Load() == 0
}

func (tc *TypeChecker) runWorker(ctx context.Context, workerID int) {
    for {
        select {
        case <-ctx.Done():
            return
        case job, ok := <-tc.jobQueue:
            if !ok {
                return
            }
            // 每个 worker 执行类型检查
            tc.checkFile(job.SourceFile, workerID)
        }
    }
}

关键设计决策：允许 worker 之间重复计算公共类型声明。这听起来是浪费，但在实践中这个策略非常有效——类型检查器的瓶颈从来不是「计算公共类型的次数」，而是「等待最慢的那个 worker」。重复计算公共类型换取更均衡的负载分布，这是典型的工程取舍。

2.3 项目引用构建器的并行化

对于 monorepo 场景，TypeScript 7.0 引入了 --builders 标志：

# 控制同时构建的项目引用数量
npx tsc --build --builders 4

# --checkers 和 --builders 的乘法效应
npx tsc --build --checkers 4 --builders 4
# 最多允许 16 个类型检查器同时运行

这个组合在大型 monorepo 中特别有价值——假设你有 10 个互相引用的包，每个包有 4 个并行 checker，理论上可以达到 40 的并发度。

2.4 实测数据：10 倍是什么量级

根据 TypeScript 团队和合作公司的公开数据（Bloomberg、Linear、Vercel 等）：

这些数字来自真实的生产代码库测试，不是刻意挑选的 benchmark 场景。值得注意的是，--watch 模式的提升比例最低但绝对收益最高——从 2.1 秒到 0.3 秒，意味着开发者按保存后几乎感觉不到延迟。

三、--watch 模式的重建：Parcel 的 Go 之旅

3.1 为什么 Parcel watcher 被移植了

TypeScript 6.x 及更早版本的 --watch 模式有一个长期痛点：在大型 monorepo 中，文件监听器（file watcher）的开销非常显著。数千个文件 + 嵌套的 node_modules + 不同操作系统的文件系统事件差异，让 watcher 成为 --watch 模式的最大瓶颈。

Go 标准库没有内置的文件系统监听 API。团队评估了多个第三方方案：

• fsnotify：跨平台实现但性能不够稳定
• watchexec：功能完整但与 TypeScript 的 watch 模式不匹配
• 其他方案：无法同时满足跨平台和高性能的需求

最终，团队选择了将 Parcel watcher 从 C++ 移植到 Go。

Parcel watcher（@parcel/watcher）是 Parcel 2 构建系统的核心组件，用 C++ 编写，是 VS Code 多年来一直在使用的文件监听方案。它的核心优势在于：跨平台高效 + 与 OS 级别的文件系统事件深度集成。

移植过程并非简单的「C++ 到 Go 的直译」。团队做了两件事：

1. 语义保留移植：通过尽可能少的汇编 shim，让 Go 版本通过 Parcel 原有的完整测试套件
2. Go 习惯重构：在保证行为一致的前提下，逐步将代码重构为更符合 Go 习惯的实现方式

// Go 移植后的 watcher 核心接口
type Watcher interface {
    // Start watching a directory
    Watch(dir string, callback func(events []FileEvent)) error
    // Stop watching
    Close() error
}

// 基于轮询 + OS 事件的混合策略
func (w *ParcelWatcher) Watch(dir string, cb func([]FileEvent)) error {
    // 1. 初始扫描：递归遍历目录树，建立文件索引
    // 2. OS 级别监听：Linux (inotify) / macOS (FSEvents) / Windows (ReadDirectoryChangesW)
    // 3. 降级策略：当 OS 监听器数量超限时，自动切换为轮询模式
    // 4. 防抖（Debounce）：合并短时间内同一文件的多次变更事件
}

3.2 跨平台的工程挑战

文件监听是跨平台开发中最「脏」的领域之一。每个操作系统的实现都不同：

• Linux：inotify，有 max_user_watches 限制（默认 8192）
• macOS：FSEvents，可以监听整个文件系统但有延迟
• Windows：ReadDirectoryChangesW，路径长度和编码问题

Go 移植版需要处理所有这些边界情况，同时保持与 Parcel C++ 版的行为一致性。TypeScript 团队在 GitHub 上开源了移植后的代码（microsoft/typescript-go 仓库），这是整个项目最值得研究的子模块之一。

四、配置断层：从 5.x 到 7.0 的完整迁移指南

4.1 为什么迁移路径是 5.x → 6.0 → 7.0，而不是直接跳

TypeScript 团队给出的建议很明确：先升级到 6.0，再迁移到 7.0。这不是在故意增加工作量，而是因为 6.0 已经引入了 7.0 的所有破坏性变更，只是以「deprecated」警告的形式出现；7.0 把它们升级为硬错误。

直接跳过 6.0 的团队会面对「一下子所有配置同时报错」的混乱场面。按部就班则可以将风险分散到两次升级中。

4.2 新默认值清单：逐项解析

TypeScript 7.0 引入的新默认值一览：

strict: true

这是影响最大的变更。strict 是一个总开关，包含了：

• strictNullChecks：严格 null/undefined 检查
• strictFunctionTypes：严格函数类型检查
• strictPropertyInitialization：类属性的严格初始化检查
• 等等

如果你的项目之前没有开启 strict，迁移成本会比较高。建议分步开启：

// tsconfig.json - 逐步开启 strict 模式
{
  "compilerOptions": {
    // 先开启影响最小的选项
    "strictNullChecks": true,
    // 逐步处理报错后，再开启下一个
    // "strict": true  // 最后一步
  }
}

types: []（自动变为空数组）

这是最容易出「惊喜」的变更。之前 TypeScript 会自动加载 node_modules/@types/ 下所有包的类型声明。7.0 改为默认不加载任何 @types/*，除非显式指定。

// 7.0 之前的 tsconfig
{
  "compilerOptions": {
    // types 会自动包含 ["node", "jest", ...]
  }
}

// 7.0 需要显式声明
{
  "compilerOptions": {
    "types": ["node", "jest", "bun"]
  }
}

这意味着你原来不需要任何配置就能用的全局类型（如 process、describe/it）现在会报「找不到名称」错误。

rootDir: "./"

之前如果 tsconfig.json 在项目根目录，TypeScript 会自动推断 rootDir 为包含 tsconfig.json 的目录。7.0 要求必须显式指定 rootDir：

// 明确指定源码目录
{
  "compilerOptions": {
    "rootDir": "./src"
  },
  "include": ["./src"]
}

4.3 硬错误清单：这些配置不再可用

以下配置在 7.0 中会直接报错，不会有警告期：

// 以下配置在 TypeScript 7.0 中会报编译错误
{
  "compilerOptions": {
    // ❌ target: es5 已完全移除
    "target": "ES5",
    
    // ❌ downlevelIteration 已不存在
    "downlevelIteration": true,
    
    // ❌ 以下 moduleResolution 已不支持
    "moduleResolution": "node",   // 改用 "nodenext" 或 "bundler"
    "moduleResolution": "node10",
    
    // ❌ 以下 module 已不支持
    "module": "amd",
    "module": "umd",
    "module": "system",
    "module": "none",
    
    // ❌ baseUrl 不再支持（paths 改为相对于项目根）
    "baseUrl": ".",
    "paths": {
      "@/*": ["src/*"]  // 现在直接相对于 rootDir
    },
    
    // ❌ esModuleInterop 不可设为 false
    "esModuleInterop": false,     // 现在始终为 true
    
    // ❌ alwaysStrict 始终为 true，不可关闭
    "alwaysStrict": false
  }
}

4.4 一个实际的迁移脚本

以下是我们在项目中实际使用的迁移脚本（适用于大多数使用 Vite + TypeScript 的项目）：

#!/bin/bash
# migrate-to-ts7.sh

set -e

echo "=== TypeScript 7.0 迁移检查 ==="

# 1. 检查当前 TypeScript 版本
CURRENT_TS=$(npx tsc --version)
echo "当前版本: $CURRENT_TS"

# 2. 检查是否已设置 strict
if grep -q '"strict": false' tsconfig.json; then
    echo "⚠️  检测到 strict: false，7.0 不兼容"
    echo "   建议：先升级到 6.0，逐步开启 strict 模式"
fi

# 3. 检查 types 配置
if grep -q '"types"' tsconfig.json; then
    echo "✅ 已显式配置 types"
else
    echo "⚠️  未显式配置 types，7.0 会默认为空数组"
    echo "   当前自动加载的 types:"
    ls node_modules/@types/ | head -20
fi

# 4. 检查是否使用了已废弃的配置
DEPRECATED=()
grep -q '"target": "es5"' tsconfig.json && DEPRECATED+=("target: es5")
grep -q '"moduleResolution": "node"' tsconfig.json && DEPRECATED+=("moduleResolution: node")
grep -q '"baseUrl"' tsconfig.json && DEPRECATED+=("baseUrl")

if [ ${#DEPRECATED[@]} -gt 0 ]; then
    echo "❌ 检测到不兼容配置:"
    for item in "${DEPRECATED[@]}"; do
        echo "   - $item"
    done
    echo "   必须先修复这些配置才能升级到 7.0"
else
    echo "✅ 未检测到不兼容配置"
fi

echo "=== 检查完成 ==="

五、Unicode 感知模板字面量类型：7.0 的语义修正

5.1 什么被改变了

这是一个有意破坏性的语义变更，涉及到模板字面量类型的处理方式。

在 TypeScript 6.x 及之前，TypeScript 遵循 JavaScript 的 UTF-16 索引行为：

type HeadTail<S> = S extends `${infer Head}${infer Tail}` ? [Head, Tail] : never;

// 6.x 行为：Emoji 被拆成两个 UTF-16 代理对
type Result = HeadTail<"😀abc">;
// TypeScript 6.x: ["\ud83d", "\ude00abc"]
// JavaScript: "😀abc"[0] === "\ud83d" ✓

// 7.0 行为：Emoji 作为完整的 Unicode 代码点
type Result = HeadTail<"😀abc">;
// TypeScript 7.0: ["😀", "abc"]

"😀" 是一个由两个 UTF-16 代码单元（\ud83d 和 \ude00）组成的代理对（surrogate pair）。6.x 把它当成两个独立字符处理，这在类型系统层面是「正确的 JavaScript 行为」，但几乎不是开发者的真实意图。

5.2 为什么这是个问题

很多工具库在类型层面做字符串操作时会用到模板字面量推断。例如，一个常见用法：

// 一个字符串字面量类型的工具
type Trim<S extends string> = 
    S extends ` ${infer T}` ? Trim<T> :
    S extends `${T} ` ? Trim<T> :
    S;

// 在 6.x 中，以下类型推断是错的：
type T1 = Trim<"  hello  ">;  
// 6.x: "hello  "（右边空格没去掉，因为 "  " 匹配 ` ${infer T}` 时出了问题）
// 7.0: "hello" ✓

这个行为变化会影响一些依赖模板字面量类型的高级类型工具。如果你的项目重度依赖这些类型工具，建议在升级后运行完整的类型检查并审查任何 never 类型的异常出现。

5.3 for...of 和展开运算符也变了

不只是模板字面量，7.0 中 for...of 循环和展开运算符也改为 Unicode 代码点感知：

const emoji = "😀abc";

// 6.x
[...emoji];        // ["\ud83d", "\ude00", "a", "b", "c"]
for (const char of emoji) { /* char = "\ud83d", "\ude00", "a"... */ }

// 7.0
[...emoji];         // ["😀", "a", "b", "c"]  
for (const char of emoji) { /* char = "😀", "a", "b"... */ }

六、JavaScript 项目（JSDoc）的支持变化

6.1 为什么 JSDoc 类型分析也被重构了

TypeScript 对纯 JavaScript 文件的类型支持是通过 JSDoc 注解实现的。这次 Go 重写也覆盖了这部分逻辑——团队决定让 JS 文件的类型分析更接近 .ts 文件的处理方式，减少两套系统之间的行为差异。

6.2 不再支持的 JSDoc 模式

// ❌ 在类型位置使用值（之前允许）
/** @type {typeof someValue} */  // 旧写法
/** @type {string} */             // 必须用具体类型名

// ❌ @enum 已废弃
/** @enum {number} */             // 旧写法
/** @typedef {number} */         // 改用 @typedef + keyof typeof

// ❌ 独立的 ? 作为类型
function foo(x?) { }              // 旧写法
function foo(x) { }               // 用具体类型或 any

// ❌ 后缀 ! 表示非空
const len = str!.length;          // 旧写法
const len = str.length;           // 直接写，或用具体类型

// ❌ Closure 风格函数类型
/** @param {string} s */          // 旧写法
/** @param {(s: string) => void} callback */  // 改用箭头函数语法

七、生态共存策略：@typescript/typescript6

7.1 为什么需要兼容包

TypeScript 7.0 的稳定程序化 API（TypeScript Compiler API）要到 7.1 才能就绪。在这之前，依赖 typescript npm 包的生态工具（typescript-eslint、ts-jest、ts-node、各种 Rollup/Vite 插件等）如何继续工作？

微软的解决方案是 @typescript/typescript6 兼容包：

# 安装 TS 6.0 兼容包（提供 tsc6 命令）
npm install -D typescript@npm:@typescript/typescript6@^6.0.0

# 同时安装 TS 7.0 RC（提供 tsc 命令）
npm install -D typescript@npm:typescript@rc

# 升级脚本示例

通过 npm aliases，typescript 包名指向 6.x（兼容生态），typescript-7 包名指向 7.0 RC。tsc 使用 7.0 的编译器，而 tsc6 使用 6.x 的 API——两者可以共存。

7.2 生态工具的迁移状态

以下是主流 TypeScript 生态工具对 7.0 RC 的支持状态（截至 2026年8月）：

八、性能调优：让 7.0 在你的机器上跑得更快

8.1 并行度配置决策树

TypeScript 7.0 的两个并行度参数：

# --checkers：每个项目的类型检查并行度
# --builders：项目引用的并行构建数

配置建议：

经验法则：--checkers 的值不要超过机器的 CPU 核心数，--builders 的值根据 monorepo 中的包数量来定，一般设为包数量的 1/3 到 1/2。

8.2 调试单线程模式

新引入的 --singleThreaded 标志强制所有工作在单线程执行：

# 用于调试和性能对比
npx tsc --build --singleThreaded

# 配合 strace / dtrace 分析性能瓶颈

8.3 CI 配置示例

# .github/workflows/ci.yml
- name: Type-check with TS 7.0
  run: |
    npx tsc --noEmit \
      --skipLibCheck \
      --checkers 4 \
      --builders 2
  env:
    NODE_OPTIONS: "--max-old-space-size=4096"

九、这不是孤例：JavaScript 工具链的「去 JS 化」浪潮

9.1 TypeScript 7.0 加入的大趋势

TypeScript 7.0 不是第一个也不会是最后一个离开 JavaScript 的工具链核心。以下是 2026 年的生态全景图：

9.2 为什么 Rust 和 Go 而不是 Rust only

这份清单里有一个有趣的现象：TypeScript 选择的是 Go，而不是更「时髦」的 Rust。Bun 选择了从 Zig 迁移到 Rust。

Ryan Cavanaugh（TypeScript 首席工程师）解释了背后的权衡：

1. Go 的简单性：TypeScript 编译器的移植策略是「方法式翻译」而非「重新设计」。Go 的控制流和数据结构与 TypeScript/JavaScript 非常接近，这让翻译工作更机械、更可验证——「翻译质量」比「代码优雅」更重要。

2. Goroutine + 共享内存并发：Go 的并发模型（goroutine + channel + 共享内存 mutex）比 Rust 的 borrow checker 更直接。类型检查器的并行化逻辑很复杂，不需要同时处理「这个对象是否被借走」的所有权检查。

3. 更快的编译时间：Go 的编译速度比 Rust 快一个数量级。在开发迭代中，编译器的编译器本身的编译速度是有意义的考量。

4. 移植成本：TypeScript 团队评估过 Rust，但迁移成本（处理 borrow checker 约束、学习曲线）比 Go 高得多，而性能收益并不显著——类型检查器不是内存分配密集型的场景，Rust 的零成本抽象优势不明显。

这给我们的工程启示：工具选型没有银弹，合适比先进更重要。Go 在这个场景下是最优选择，不是因为 Go 比 Rust 更好，而是因为 TypeScript 编译器的特点恰好适合 Go 的语言模型。

十、实战迁移路径总结

10.1 升级时间线建议

当前状态          推荐行动
─────────────────────────────────────────────────
TS 5.x           → 先升级到 6.0，逐步开启 strict 模式
TS 6.x（已配好） → 可以考虑升级到 7.0 RC，测试生态兼容性
TS 6.x（未配好） → 先完善 6.0 配置，再等 7.0 稳定版

10.2 快速检查清单

在升级到 7.0 之前，用这个清单快速评估迁移成本：

# 复制并运行以下检查命令
# 1. 统计 @types 依赖数量
ls node_modules/@types/ | wc -l

# 2. 检查是否使用了已废弃配置
grep -E '"target"|"moduleResolution"|"baseUrl"|"module"' tsconfig.json | grep -v nodenext | grep -v bundler | grep -v esnext

# 3. 检查是否关闭了 strict
grep '"strict": false' tsconfig.json

# 4. 检查 rootDir 是否已显式指定
grep '"rootDir"' tsconfig.json

10.3 升级后的验证步骤

# 1. 安装 TS 7.0 RC
npm install -D typescript@rc

# 2. 验证版本
npx tsc --version  # 应该显示 7.0

# 3. 全量类型检查
npx tsc --noEmit --skipLibCheck 2>&1 | head -100

# 4. 如果使用了 @types，确保显式配置
# 检查是否有任何 "找不到名称" 的错误

# 5. 运行测试套件
npm test

# 6. ESLint 类型检查
npx eslint --max-warnings 0 src/

结语

TypeScript 7.0 的意义远不止「10 倍提速」这一串数字。它代表了一种工程哲学：当你在某个技术栈上遇到了系统性的性能瓶颈，与其永远在它的规则下打补丁，不如从底层换一个起点。

这不是说 JavaScript/TypeScript 不好——恰恰相反。TypeScript 语言本身（类型系统、语义规则）在这次迁移中完全保留。这说明好的抽象设计是可以在不同实现之间「无缝迁移」的。真正被替换的，是执行这些抽象的底层基础设施。

对于 TypeScript 用户而言，7.0 带来的最直接价值是：不用担心「这个特性会不会让 tsc 变慢」。从今往后，TypeScript 编译器可以在 Go 的并发模型上自由演进，不再需要为了性能而牺牲语言特性的丰富度。

下一次当你为 TypeScript 添加一个复杂的类型工具函数时，记得：你写的是语言特性，而不再需要担心编译器会因此变慢。这，大概就是一次技术迁移最好的意义。

参考资源

• Announcing TypeScript 7.0 RC（微软官方博客）
• TypeScript Go 移植仓库（GitHub）
• Parcel watcher Go 移植（@parcel/watcher）

本文涉及的性能数据来源于 TypeScript 团队公开的基准测试和合作公司的生产环境报告。实际提升倍数因项目规模、代码特性和硬件配置不同而有所差异。