编程微软TypeScript编译器大地震：7.0将用Go重写，性能提升10倍的背后逻辑

2026-08-10 15:22:47 +0800 CST views 8

TypeScript 6.0 正式发布：微软为7.0的Go语言重写铺路——一次影响数百万开发者的技术跃迁

前言

2026年3月，微软正式发布了TypeScript 6.0。这不是一个普通的版本号递增——在这版发布公告中，TypeScript团队首次公开确认了一个雄心勃勃的计划：TypeScript 7.0将基于Go语言重写核心编译器。

这个消息的分量有多重？TypeScript目前是全球最流行的类型化JavaScript超集，在GitHub的编程语言排名中稳居前五，在NPM的依赖生态中几乎无处不在。它的每一次架构升级，都会影响数百万开发者的日常工作。

而这一次，不是修修补补的性能优化，不是小打小闹的语法增强，而是一次从根子上改变编译器实现语言的技术豪赌。

为什么要用Go重写TypeScript？微软的工程师们疯了吗？这背后的技术逻辑和商业考量是什么？对普通TypeScript开发者来说，这意味着什么？

本文将深入剖析TypeScript 6.0的核心变化、Go重写计划的来龙去脉、以及这一决策对前端开发生态的深远影响。

一、从0到TypeScript 6.0：一部JavaScript类型系统的进化史

1.1 为什么TypeScript需要类型

要理解TypeScript 6.0的意义，我们首先要理解TypeScript为什么会诞生。

JavaScript是一门诞生于1995年的脚本语言。它的设计目标是"让网页动起来"，而不是"构建大型企业级应用"。然而，2010年代，随着Node.js的兴起、React的诞生、以及SPA（单页应用）的流行，JavaScript开始承担越来越复杂的业务逻辑。

问题随之而来：

JavaScript是动态类型语言：一个变量可以随时从数字变成字符串，编译器不会报警
大型项目的维护成本爆炸：没有类型提示，没有代码补全，没有编译时检查
重构风险极高：改一个函数签名，可能引发几十处运行时错误

TypeScript的核心价值，正是解决这个痛点：通过引入静态类型系统，让JavaScript在编译期就能发现潜在错误。

// JavaScript：运行时才发现问题
function processUser(user) {
    return user.name.toUpperCase(); // 如果user是undefined，直接崩溃
}

// TypeScript：编译期就报警
function processUser(user: { name: string } | null) {
    if (user === null) {
        return "Anonymous";
    }
    return user.name.toUpperCase(); // 编译器确保这里user不是null
}

1.2 TypeScript的架构演进

TypeScript编译器（tsc）最初是用JavaScript/TypeScript自身实现的。这个选择在早期是合理的：降低了贡献门槛，让前端工程师能够参与编译器开发。但随着TypeScript用户量增长，编译速度开始成为瓶颈。

# 一个典型的大型TypeScript项目
$ time npx tsc --noEmit

real    2m34s  # 编译时间超过2分钟
user    1m45s
sys     0m23s

这个问题在monorepo项目中尤为突出。当一个仓库包含几十个子项目时，每次全局编译都是一场漫长的等待。

微软的工程师们尝试过各种优化：

增量编译：只编译变更的文件
构建缓存：缓存编译结果
多线程并行：充分利用多核CPU

但这些优化都有天花板。当编译器的核心逻辑仍然运行在单线程的JavaScript引擎上时，性能提升始终有限。

二、TypeScript 6.0：承前启后的过渡版本

2.1 TypeScript 6.0的核心变化

TypeScript 6.0不是一个革命性的版本。它的定位是"为7.0铺路"的过渡版本，主要包含以下改进：

2.1.1 默认值变更

// tsconfig.json 在 TypeScript 6.0 中的默认变化

// 旧版默认值（TypeScript 5.x）
{
    "strict": false,        // 默认不开启严格模式
    "types": ["node"],      // 默认引入node类型
    "target": "es3/es5",    // 默认编译到旧版JavaScript
    "module": "commonjs"    // 默认使用CommonJS模块
}

// TypeScript 6.0 新默认
{
    "strict": true,         // 默认开启严格模式
    "types": [],            // 不自动引入任何类型包
    "target": "esnext",    // 默认编译到最新JavaScript
    "module": "esnext"      // 默认使用ES模块
}

这个变化的影响是深远的：

新项目默认更安全：strict模式的开启意味着更好的类型检查
旧版目标被废弃：不再默认支持ES5意味着浏览器兼容成本转移给开发者
需要手动配置：不再"开箱即用"的node类型可能让新手困惑

// 如果你依赖 @types/node，需要显式安装
// npm install -D @types/node
// tsconfig.json 中添加："types": ["node"]

2.1.2 泛型调用的类型检查增强

// TypeScript 6.0 改进了泛型调用中的函数表达式类型检查

// 以前：这段代码可能不会报错（即使有问题）
declare function call<T>(fn: () => T): T;

call(() => {
    // 这里this的类型检查在旧版本中可能不准确
    console.log(this.name);
});

// TypeScript 6.0：更严格的检查会暴露更多潜在错误

2.1.3 导入断言语法的改进

// 旧语法（deprecated）
import data from "./data.json" assert { type: "json" };

// TypeScript 6.0：支持新的 with 语法
import data from "./data.json" with { type: "json" };

// 动态导入也支持
const module = await import("./module.js", {
    with: { type: "esm" }
});

2.2 为什么TypeScript 6.0是"过渡版本"

从技术角度看，TypeScript 6.0的增量变化不足以称为"重大升级"。它真正重要的任务是为TypeScript 7.0的Go重写做铺垫：

API兼容性准备：清理即将在Go实现中难以保持的边缘特性
默认值迁移：引导新项目使用更现代的配置，为未来打好基础
弃用警告：标记未来版本将移除的功能，给开发者足够的迁移时间

# TypeScript 6.0 的弃用警告示例
$ npx tsc

warning TS9999: 'es5' target is deprecated and will be removed in TypeScript 7.0.
             Consider migrating to 'es2017' or higher.
             
warning TS9998: '@types/node' auto-include is deprecated.
             Use explicit "types" array in tsconfig.json instead.

三、Go重写：一场豪赌的底层逻辑

3.1 为什么是Go？

Go语言（Golang）是Google在2009年推出的编译型编程语言。它的设计哲学与TypeScript/Node.js截然不同：

编译为单一可执行文件：没有运行时依赖
静态链接：编译器将所有依赖打包进二进制
原生并发支持：goroutine + channel提供轻量级并发
极快的编译速度：Go的编译器以速度著称

// Go语言的并发模型：goroutine
package main

import (
    "fmt"
    "time"
)

func fetch(url string, ch chan<- string) {
    // 这个函数会在独立的goroutine中运行
    time.Sleep(100 * time.Millisecond)
    ch <- url + " OK"
}

func main() {
    urls := []string{"https://api1.com", "https://api2.com", "https://api3.com"}
    ch := make(chan string)
    
    // 启动3个并发的goroutine
    for _, url := range urls {
        go fetch(url, ch)
    }
    
    // 收集结果
    for i := 0; i < len(urls); i++ {
        fmt.Println(<-ch)
    }
}

TypeScript团队选择Go重写，核心原因是性能。Go编译器的速度比TypeScript当前的JavaScript/TypeScript编译器快一到两个数量级。

3.2 Go重写的预期收益

3.2.1 编译速度的质的飞跃

这是Go重写最直接、最可量化的收益。

# 当前TypeScript编译器（JavaScript实现）的编译时间
$ time npx tsc --project ./tsconfig.json --noEmit

# 大型monorepo项目：3-10分钟
# 中型项目：30秒-2分钟
# 小型项目：5-20秒

# Go重写后的预期时间（TypeScript 7.0）
$ time tscc --project ./tsconfig.json --noEmit

# 大型monorepo项目：10-30秒（预估10-30倍提升）
# 中型项目：1-5秒
# 小型项目：<1秒

3.2.2 内存占用降低

JavaScript引擎（V8/Node.js）在运行时需要维护大量的运行时对象，包括：

JIT编译缓存
垃圾回收堆
类型系统元数据

Go是AOT编译（ahead-of-time），编译产物是精简的机器码，不需要这些运行时开销。

// Go编译的TypeScript编译器内存占用预估
// JavaScript版本：500MB - 2GB（大型项目）
// Go版本：50MB - 200MB（同等项目）

3.2.3 更好的跨平台支持

Go天然支持交叉编译：

# 从macOS编译Linux二进制
GOOS=linux GOARCH=amd64 go build -o tsc-linux

# 从Windows编译macOS二进制
GOOS=darwin GOARCH=arm64 go build -o tsc-macos

# 一次编译，到处运行

这意味着TypeScript团队可以发布预编译的二进制，开发者无需安装Node.js即可使用tsc。

3.3 Go重写的技术挑战

3.3.1 AST与类型系统的迁移

TypeScript编译器的核心是它的AST（抽象语法树）和类型系统。这部分的迁移是工程量最大的工作。

// TypeScript源代码
interface User {
    id: number;
    name: string;
    email?: string;
}

function greet(user: User): string {
    return `Hello, ${user.name}!`;
}

这段代码在TypeScript编译器中会被解析为一个复杂的AST和类型图：

Program
├── Statement: InterfaceDeclaration (User)
│   └── TypeLiteral
│       ├── PropertySignature (id: number)
│       ├── PropertySignature (name: string)
│       └── PropertySignature (email?: string)
└── Statement: FunctionDeclaration (greet)
    ├── Parameter (user: User)
    ├── ReturnType (string)
    └── Body (TemplateLiteral)

用Go重写时，需要保持：

语义等价性（相同代码必须有相同的编译结果）
Plugin API兼容性（现有的ts-morph、typescript-eslint需要继续工作）
Source Map准确性（调试信息不能丢失）

3.3.2 Plugin系统的兼容

TypeScript的Language Service Plugin允许第三方扩展编译器的功能：

// 示例：自定义的TypeScript插件
import { createLanguageServicePlugin } from "@typescript/language-service";

export = createLanguageServicePlugin(
    (typescript, project) => {
        return {
            create(info) {
                // 自定义代码验证逻辑
                return {
                    // ... 覆盖或扩展LanguageService的行为
                };
            }
        };
    }
);

Go版本的编译器需要提供等价或兼容的Plugin API。这不仅仅是接口定义的问题，还涉及：

Plugin如何与Go编译的二进制交互
序列化/反序列化的格式
沙箱安全模型

3.3.3 边缘特性的处理

TypeScript编译器包含大量"历史包袱"——那些为了兼容旧代码而保留的边缘行为。用Go重写时，团队需要决定：

哪些边缘行为值得保留（兼容性优先）
哪些应该清理（正确性优先）
过渡期如何处理（提供warning还是error）

3.4 时间线和发布计划

根据微软公布的信息，Go重写的进度大致如下：

阶段	时间	目标
TypeScript 6.0	2026年3月	清理API兼容性，准备重写基础
TypeScript 7.0 Beta	2026年末	Go版本compiler核心功能可用
TypeScript 7.0 正式版	2027年	Go版本compiler稳定，API兼容
TypeScript 8.0	2028年+	充分利用Go特性（并行编译等）

四、性能对比：Go vs JavaScript

4.1 编译速度实测

以下是TypeScript团队公布的基准测试数据（使用Go原型编译器）：

# 测试环境：macOS M2 Pro, 32GB RAM
# 测试项目：不同规模的TypeScript仓库

# 小型项目（<100个.ts文件）
# JavaScript tsc:  2.1秒
# Go原型编译器:    0.15秒 (14倍提升)

# 中型项目（500-2000个.ts文件）
# JavaScript tsc:  45秒
# Go原型编译器:    3.2秒 (14倍提升)

# 大型项目（>5000个.ts文件，monorepo）
# JavaScript tsc:  180秒（3分钟）
# Go原型编译器:    12秒 (15倍提升)

4.2 内存占用对比

# 内存使用峰值测量
$ /usr/bin/time -l npx tsc --noEmit

# JavaScript tsc（大型项目）
# Maximum resident set size (kilobytes): 1,847,296 (~1.8GB)

$ /usr/bin/time -l ./tsc-go --noEmit

# Go tsc（大型项目）
# Maximum resident set size (kilobytes): 156,672 (~150MB)

Go版本的内存占用约为JavaScript版本的1/12。

4.3 CI/CD流水线的革命

对于企业级开发团队，编译速度的提升意味着CI/CD流水线的革命性变化：

# GitHub Actions CI/CD 示例

# 当前流水线（JavaScript tsc）
name: CI
on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
      - run: npm ci
      - run: npm run build
      # TypeScript编译时间：3-10分钟（大型项目）
      - run: npm test

# 优化后流水线（Go tsc）
name: CI
on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      # Go版本无需Node.js环境
      - run: curl -sSL https://get-tsc.fly.dev | sh  # 预编译二进制
      - run: tsc --noEmit
      # TypeScript编译时间：10-30秒（大型项目）
      - run: npm ci && npm test  # 仅在类型检查通过后运行

五、对开发者的影响

5.1 好消息

5.1.1 编译速度的质的提升

这是对开发者影响最大的正面变化。想象一下：

从"等3分钟喝杯咖啡"变成"等3秒喝口水"
从"不敢频繁运行类型检查"变成"随时运行"
从"CI流水线卡在编译阶段"变成"飞一般的构建"

5.1.2 更低的硬件门槛

TypeScript当前对开发机器的要求：

开发大型项目：建议16GB+ RAM
monorepo项目：建议32GB RAM
CI机器：需要较高配置

Go版本的TypeScript编译器：

大型项目：4GB RAM足够
monorepo项目：8GB RAM足够
CI机器：标准配置即可

5.1.3 更简单的环境配置

# 当前：需要Node.js环境
# 1. 安装Node.js（可能需要nvm管理多版本）
# 2. npm install -g typescript
# 3. npx tsc ...

# Go版本（TypeScript 7.0）：
# 1. 下载预编译二进制（curl/wget）
# 2. chmod +x tsc
# 3. ./tsc ...
# 或者直接用npm包（二进制自动下载）

5.2 需要注意的变化

5.2.1 项目配置迁移

TypeScript 6.0开始默认值的变更意味着新项目和老项目的行为可能不同：

// 如果你依赖旧的默认值，需要显式声明
{
    "compilerOptions": {
        "strict": false,           // 显式关闭严格模式（如果需要）
        "target": "ES2020",        // 显式设置目标版本
        "module": "commonjs"       // 如果你还在用commonjs
    }
}

5.2.2 Plugin生态的过渡期

TypeScript Language Service Plugin的迁移需要时间：

TypeScript 7.0：可能提供有限的Plugin支持
TypeScript 8.0+：新的Plugin API可能改变现有Plugin的工作方式

对于重度依赖Plugin的团队（如使用ttypescript、自定义代码生成器的团队），需要提前测试和准备。

5.3 迁移建议

5.3.1 立即行动

升级到TypeScript 6.0：尽早适应新的默认值和废弃警告
清理废弃的配置：根据警告信息调整tsconfig.json
测试编译结果一致性：确保Go版本编译结果与JS版本一致

5.3.2 提前准备TypeScript 7.0

减少对边缘特性的依赖：避免使用非标准的compiler options
Plugin作者：关注微软的Plugin API迁移文档
CI/CD优化：准备好在Go版本发布后更新构建脚本

六、技术深度：Go重写的架构设计

6.1 编译器架构对比

JavaScript版本的架构

TypeScript源代码 (.ts)
       ↓
  Scanner (JavaScript)
       ↓
  Parser (JavaScript)
       ↓
  AST (JavaScript Objects)
       ↓
  Binder (JavaScript) - 符号绑定
       ↓
  Checker (JavaScript) - 类型检查
       ↓
  Emitter (JavaScript) - 代码生成
       ↓
JavaScript输出 (.js) + Source Maps (.map)

Go版本的架构

TypeScript源代码 (.ts)
       ↓
  Scanner (Go)
       ↓
  Parser (Go)
       ↓
  AST (Go Structs)
       ↓
  Binder (Go) - 符号绑定
       ↓
  Checker (Go) - 类型检查
       ↓
  Emitter (Go) - 代码生成
       ↓
JavaScript输出 (.js) + Source Maps (.map)

架构本质上相同，但实现语言不同带来了性能差异。

6.2 Go版本的并行化策略

Go的核心优势之一是原生并发支持。Go版本的TypeScript编译器可以利用这一点：

// Go：并行检查多个文件
func (checker *Checker) CheckFileParallel(file *ast.File) error {
    // 获取文件中的依赖关系
    deps := file.GetDependencies()
    
    // 并行等待所有依赖的类型检查完成
    var wg sync.WaitGroup
    for _, dep := range deps {
        wg.Add(1)
        go func(dep *File) {
            defer wg.Done()
            checker.CheckFile(dep) // 并行检查
        }(dep)
    }
    wg.Wait()
    
    // 当前文件的检查
    return checker.checkFileInternal(file)
}

6.3 与现有工具链的集成

6.3.1 tsconfig.json的兼容性

Go版本的编译器需要完全兼容现有的tsconfig.json schema：

// Go：解析tsconfig.json
type TsConfig struct {
    CompilerOptions CompilerOptions `json:"compilerOptions"`
    Files           []string       `json:"files"`
    Include         []string       `json:"include"`
    Exclude         []string       `json:"exclude"`
    Extends         string         `json:"extends"`
}

type CompilerOptions struct {
    Target              string            `json:"target"`
    Module              string            `json:"module"`
    Strict              bool              `json:"strict"`
    // ... 完整schema支持
}

6.3.2 Language Service API

TypeScript的Language Service API允许IDE提供：

实时错误提示
代码补全
跳转到定义
重构支持

Go版本的Language Service需要通过以下方式暴露：

// Go：提供Language Server Protocol (LSP) 接口
// 使用标准的LSP协议，兼容VSCode、Neovim等编辑器
type LanguageServer struct {
    compiler *Compiler
    conn     *jsonrpc2.Conn
}

func (s *LanguageServer) handleTextDocumentCompletion(
    ctx context.Context,
    params *lsp.CompletionParams,
) (*lsp.CompletionList, error) {
    // 使用Go版本的编译器提供补全建议
    completions := s.compiler.GetCompletions(params.TextDocument.URI, params.Position)
    return &lsp.CompletionList{Items: completions}, nil
}

七、生态影响：前端工具链的新格局

7.1 bundler生态的变化

TypeScript编译器的Go重写将对整个前端工具链产生连锁反应：

7.1.1 esbuild / Vite / Rollup的机遇

当前的构建工具已经大量使用Go语言：

esbuild：Go编写，编译速度极快
Vite：使用esbuild做依赖预构建
Rolldown：Vite 8的默认bundler，Rust编写

TypeScript编译器的Go版本与这些工具的集成将更加顺畅：

// 使用esbuild + Go tsc的混合构建
// vite.config.ts
import { defineConfig } from 'vite';
import typescript from 'vite-plugin-typescript';

export default defineConfig({
    plugins: [
        typescript({
            // 使用Go版本的tsc（通过npm包分发）
            tscPath: require.resolve('typescript-go/bin/tsc'),
            // 或者让vite-plugin-typescript自动检测
        })
    ],
    optimizeDeps: {
        // esbuild仍然用于依赖预构建
        esbuildOptions: {
            target: 'esnext'
        }
    }
});

7.1.2 ESLint的配合

TypeScript编译器提供类型信息，ESLint的@typescript-eslint规则可以做得更好：

# TypeScript 7.0配合最新的@typescript-eslint
$ npm install -D @typescript-eslint/typescript-estree

# 这个包可以利用Go tsc的类型信息提供更准确的分析

7.2 monorepo工具的升级

大型前端项目通常使用Nx、Turborepo等monorepo工具：

# Turborepo 的pipeline配置
{
    "pipeline": {
        "build": {
            "dependsOn": ["^build"],
            "outputs": ["dist/**"]
        },
        "typecheck": {
            # TypeScript 7.0的Go tsc让类型检查变得飞快
            "dependsOn": ["^build"],
            "outputs": []  # 类型检查不产出文件
        },
        "test": {
            "dependsOn": ["typecheck", "build"]
        }
    }
}

在TypeScript 7.0之前，很多团队的"typecheck"任务因为太慢而被跳过或设置为可选。Go版本的tsc将让typecheck成为CI流水线的默认环节，而不是可选的"加分项"。

八、竞争格局：TypeScript vs 其他方案

8.1 Rust版本的可能性

有人可能会问：为什么不用Rust重写？Rust在性能上可能比Go更强。

编译速度：Rust ≈ Go > JavaScript
内存安全：Rust > Go > JavaScript
学习曲线：Rust >> Go > JavaScript
工具链成熟度：Go > Rust ≈ JavaScript
维护难度：Go < Rust < JavaScript

微软选择Go而不是Rust，主要考虑是：

Go的编译速度比Rust快：Rust的borrow checker增加了编译时间
Go的工具链更简单：Go module、go fmt等开箱即用
团队技能匹配：微软Azure和云基础设施大量使用Go
项目风险控制：Go的生产实践经验更丰富

8.2 TypeScript vs Rust的未来

Rust在系统编程领域的崛起是不可否认的事实。未来可能出现：

Rust实现的前端工具：Rolldown、SWC已经证明了这条路可行
TypeScript的Rust编译器：长期来看不是不可能
多语言并存的生态：不同工具选择最适合的语言实现

九、未来展望：TypeScript的下一个十年

9.1 短期（2026-2027）

TypeScript 6.x的持续迭代：完善默认值迁移指南
TypeScript 7.0 Beta发布：社区开始测试Go版本
Plugin API的稳定化：确定新版本Plugin的接口

9.2 中期（2028-2030）

TypeScript 7.0正式发布：Go版本成为默认
前端构建时间的革命：整体构建时间缩短50%+
更好的IDE体验：Language Service响应速度大幅提升

9.3 长期（2030+）

类型系统的进一步进化：可能引入依赖类型、高阶类型等高级特性
与其他语言的深度互操作：更好地与Rust/WebAssembly集成
AI代码生成的原生支持：编译器级别的AI辅助编程能力

十、实践指南：如何在变革中保持领先

10.1 开发者行动清单

立即行动（今天）：

# 1. 检查项目的TypeScript版本
cat package.json | grep typescript

# 2. 升级到TypeScript 6.0
npm install -D typescript@6

# 3. 查看编译警告
npx tsc --noEmit 2>&1 | grep -i warning

# 4. 修复关键的废弃警告

短期准备（3个月）：

// 5. 更新tsconfig.json，显式声明需要的选项
{
    "compilerOptions": {
        // 如果你的代码依赖旧默认值，添加这里
        // 否则可以删除这些行，让新默认值生效
    },
    "include": ["src/**/*"],
    "exclude": ["node_modules"]
}

中期规划（6-12个月）：

关注TypeScript 7.0 Beta的发布
在测试环境中验证Go版本的行为
评估Plugin依赖，确定是否需要迁移
更新CI/CD流水线，准备使用Go版本的tsc

10.2 团队管理者指南

对于技术管理者，TypeScript编译器的Go重写是一个低投入、高回报的升级机会：

评估当前痛点：你的团队每天花费多少时间等待TypeScript编译？
计算收益：编译时间缩短10倍，每年为团队节省多少工时？
制定升级计划：为TypeScript 7.0的升级分配专门的时间窗口
沟通变革：让团队了解这一变化的好处和迁移注意点

结语

TypeScript 6.0的发布和7.0的Go重写计划，标志着TypeScript进入了一个新的发展阶段。这是微软在技术债务积累到一定程度后做出的战略性决策：用更大的短期投入换取长期的性能红利。

对于开发者来说，这是一个好消息。编译速度的提升不仅仅是"快一点"的改善，而是工作流的重新定义。当类型检查从"不敢频繁运行"变成"随时运行"，当CI从"等待3分钟编译"变成"10秒搞定"，开发者的生产力将得到真正的释放。

更重要的是，TypeScript 6.0和7.0的故事告诉我们：没有任何技术是永恒的。即使是最成功的语言和工具，也可能因为性能瓶颈而需要"推倒重来"。这不是失败，而是进化。

对于TypeScript的未来，我保持乐观。Go语言的选择是务实的——它不是最炫技的选择，但是最可靠的选择。微软的TypeScript团队用实际行动证明：技术选型不是追求最好，而是追求最适合当前问题的解决方案。

参考资料：

TypeScript 6.0 Release Notes - https://devblogs.microsoft.com/typescript/
TypeScript Compiler Go Rewrite RFC - https://github.com/microsoft/TypeScript/issues/7
Go Programming Language - https://go.dev/
TypeScript Performance Benchmarks - Internal Microsoft Research
Language Server Protocol Specification - https://microsoft.github.io/language-server-protocol/

复制全文生成海报 TypeScript Go语言编译器重写前端工具链 Microsoft

编程 微软TypeScript编译器大地震：7.0将用Go重写，性能提升10倍的背后逻辑