Rust vs Go：2026年你应该选择哪种语言？

spinny:~/writing $ vim rust-vs-go-comparison.md

1~
2Rust和Go是2026年最受关注的两种系统编程语言。自2016年以来，Rust在每次Stack Overflow调查中都被评为"最受喜爱的语言"。Go为互联网上一些最关键的基础设施提供支持，从Docker和Kubernetes到Cloudflare的边缘网络。
3~
4但它们以根本不同的方式解决不同的问题。在本文中，我们从对选择正确工具至关重要的每个维度对它们进行比较。
5~
6## 概览
7~
8| 方面 | Rust | Go |
9|------|------|-----|
10| **创建者** | Mozilla (2010) | Google (2009) |
11| **类型系统** | 静态、强类型、带所有权 | 静态、强类型、更简单 |
12| **内存管理** | 所有权 + 借用（无GC） | 垃圾回收器 |
13| **并发** | async/await、线程、通道 | Goroutines + 通道 |
14| **编译** | 较慢 | 非常快 |
15| **二进制大小** | 小、静态 | 小、静态 |
16| **学习曲线** | 陡峭 | 平缓 |
17| **错误处理** | Result/Option类型 | 多返回值 |
18| **空值安全** | 无null（Option类型） | 有nil |
19| **泛型** | 是（自1.0起） | 是（自1.18起） |
20~
21## 性能
22~
23Rust产生与C和C++相当的性能，没有垃圾回收器暂停。它让你完全控制内存布局和分配。
24~
25Go很快 - 比Python、JavaScript或Java快得多 - 但它有一个垃圾回收器，可能在性能关键的应用中引入延迟峰值。
26~
27```rust
28// Rust: Zero-cost abstractions
29fn sum_even(numbers: &[i32]) -> i32 {
30    numbers.iter()
31        .filter(|&&n| n % 2 == 0)
32        .sum()
33}
34```
35~
36```go
37// Go: Simple and clear
38func sumEven(numbers []int) int {
39    sum := 0
40    for _, n := range numbers {
41        if n%2 == 0 {
42            sum += n
43        }
44    }
45    return sum
46}
47```
48~
49两者都编译为原生代码。区别在于Rust的抽象（迭代器、闭包）编译为与手写循环相同的机器代码，而Go的简洁性有时意味着更少的优化潜力。
50~
51**选择Rust如果**：亚毫秒级延迟很重要（交易系统、游戏引擎、嵌入式）
52**选择Go如果**：吞吐量比延迟更重要（Web服务、CLI工具、DevOps）
53~
54## 内存安全
55~
56这是Rust的标志性特性。所有权系统在编译时捕获内存错误 - 没有空指针解引用、没有数据竞争、没有释放后使用。
57~
58```rust
59// Rust: This won't compile - ownership prevents use-after-free
60fn main() {
61    let s1 = String::from("hello");
62    let s2 = s1; // s1 is moved to s2
63    // println!("{}", s1); // ERROR: s1 is no longer valid
64    println!("{}", s2); // OK
65}
66```
67~
68```go
69// Go: nil can cause runtime panics
70func main() {
71    var s *string = nil
72    fmt.Println(*s) // PANIC at runtime: nil pointer dereference
73}
74```
75~
76Rust消除了Go（以及大多数其他语言）只能在运行时捕获的整类错误。
77~
78**选择Rust如果**：安全性至关重要（密码学、操作系统组件、浏览器）
79**选择Go如果**：垃圾回收器的安全保证对你的用例来说足够了
80~
81## 并发
82~
83两种语言都擅长并发，但方式截然不同。
84~
85### Go：Goroutines
86~
87Go的并发模型简单而优雅。Goroutines是由Go运行时管理的轻量级线程，通道支持它们之间的安全通信。
88~
89```go
90func fetchAll(urls []string) []string {
91    results := make(chan string, len(urls))
92~
93    for _, url := range urls {
94        go func(u string) {
95            resp, _ := http.Get(u)
96            body, _ := io.ReadAll(resp.Body)
97            results <- string(body)
98        }(url)
99    }
100~
101    var bodies []string
102    for range urls {
103        bodies = append(bodies, <-results)
104    }
105    return bodies
106}
107```
108~
109### Rust：async/await + Tokio
110~
111Rust的异步模型更复杂，但给你更多控制。编译器在编译时防止数据竞争。
112~
113```rust
114use tokio;
115use reqwest;
116~
117async fn fetch_all(urls: Vec<String>) -> Vec<String> {
118    let mut handles = vec![];
119~
120    for url in urls {
121        handles.push(tokio::spawn(async move {
122            reqwest::get(&url)
123                .await
124                .unwrap()
125                .text()
126                .await
127                .unwrap()
128        }));
129    }
130~
131    let mut results = vec![];
132    for handle in handles {
133        results.push(handle.await.unwrap());
134    }
135    results
136}
137```
138~
139**选择Go如果**：你想要简单、易于理解的并发
140**选择Rust如果**：你需要有保证的线程安全和零成本异步
141~
142## 开发者体验
143~
144### Go：简洁优先
145~
146Go被设计为简单的。语言规范只有几页。通常只有一种显而易见的做事方式。
147~
148- **编译速度快**：Go几乎瞬间编译
149- **内置齐全**：net/http、encoding/json、testing - 全部在标准库中
150- **gofmt**：一种格式化风格，没有争论
151- **容易学习**：Java/Python开发者可以在几天内上手
152~
153### Rust：强大但复杂
154~
155Rust更难学习，但以更多的表达力和安全性回报你。
156~
157- **编译较慢**：借用检查器和单态化需要时间
158- **Cargo**：优秀的包管理器和构建工具
159- **丰富的类型系统**：枚举、模式匹配、trait、泛型
160- **更陡的曲线**：所有权模型需要数周才能内化
161~
162```rust
163// Rust's expressive error handling
164fn parse_config(path: &str) -> Result<Config, ConfigError> {
165    let content = std::fs::read_to_string(path)
166        .map_err(ConfigError::IoError)?;
167~
168    let config: Config = serde_json::from_str(&content)
169        .map_err(ConfigError::ParseError)?;
170~
171    Ok(config)
172}
173```
174~
175```go
176// Go's straightforward error handling
177func parseConfig(path string) (*Config, error) {
178    content, err := os.ReadFile(path)
179    if err != nil {
180        return nil, fmt.Errorf("reading config: %w", err)
181    }
182~
183    var config Config
184    if err := json.Unmarshal(content, &config); err != nil {
185        return nil, fmt.Errorf("parsing config: %w", err)
186    }
187~
188    return &config, nil
189}
190```
191~
192## 生态系统和用例
193~
194### Go的优势领域
195~
196- **云基础设施**：Docker、Kubernetes、Terraform、Prometheus
197- **Web服务和API**：使用net/http或Gin/Fiber的快速HTTP服务器
198- **CLI工具**：cobra、urfave/cli
199- **DevOps工具**：大多数云原生工具都用Go编写
200- **微服务**：部署简单、二进制文件小、启动快
201~
202### Rust的优势领域
203~
204- **系统编程**：操作系统组件、驱动程序、嵌入式
205- **WebAssembly**：一流的WASM支持
206- **性能关键服务**：Cloudflare Workers、Discord的消息系统
207- **区块链**：Solana、Polkadot、许多加密项目
208- **游戏引擎**：Bevy引擎
209- **CLI工具**：ripgrep、bat、fd、starship
210~
211### 使用各语言的公司
212~
213| Go | Rust |
214|----|------|
215| Google (Kubernetes, gRPC) | Mozilla (Firefox) |
216| Docker | Cloudflare (Workers) |
217| Uber | Discord（消息存储） |
218| Twitch | Dropbox（文件同步） |
219| Hashicorp (Terraform) | AWS (Firecracker) |
220| Cloudflare | Microsoft（Windows组件） |
221~
222## 何时选择Go
223~
2241. **构建Web服务和API** - Go的简洁性和net/http使其非常理想
2252. **你的团队是系统编程新手** - Go的学习曲线更加平缓
2263. **你需要快速迭代** - Go瞬间编译，非常适合快速原型开发
2274. **DevOps和基础设施工具** - 生态系统无与伦比
2285. **微服务** - 小二进制文件、快速启动、简单部署
229~
230## 何时选择Rust
231~
2321. **性能不可妥协** - 零成本抽象、没有GC暂停
2332. **安全性至关重要** - 内存安全保证防止整类错误
2343. **WebAssembly** - 一流的WASM支持
2354. **嵌入式系统** - 无运行时、无GC、可预测的性能
2365. **替代C/C++** - 相同的性能加上内存安全
237~
238## 可以同时使用两者吗？
239~
240可以。许多组织同时使用两者：
241~
242- **Go** 用于Web服务、API和DevOps工具
243- **Rust** 用于性能关键的组件和库
244~
245它们可以通过FFI（外部函数接口）、gRPC或服务间的REST API进行互操作。
246~
247```mermaid
248graph LR
249    subgraph "Go Services"
250        API[API Gateway\nGo]
251        Auth[Auth Service\nGo]
252    end
253~
254    subgraph "Rust Services"
255        Search[Search Engine\nRust]
256        ML[ML Pipeline\nRust]
257    end
258~
259    API -- gRPC --> Search
260    API -- gRPC --> Auth
261    API -- gRPC --> ML
262```
263~
264## 总结
265~
266Go和Rust都是优秀的语言，但它们为不同的事物进行优化：
267~
268- **Go为简洁性优化** - 学习快、编译快、发布快
269- **Rust为正确性优化** - 安全、快速、表达力强，但更难学习
270~
271如果你正在构建Web服务、API或DevOps工具并想要快速前进，选择Go。如果你正在构建性能关键、安全关键或系统级别的软件，选择Rust。
272~
273最佳选择取决于你的团队、你的约束和你的优先级。两种语言在2026年及以后都会为你提供良好的服务。
274~

NORMAL · rust-vs-go-comparison.md [readonly]274 lines · :q to close

2Rust和Go是2026年最受关注的两种系统编程语言。自2016年以来，Rust在每次Stack Overflow调查中都被评为"最受喜爱的语言"。Go为互联网上一些最关键的基础设施提供支持，从Docker和Kubernetes到Cloudflare的边缘网络。

4但它们以根本不同的方式解决不同的问题。在本文中，我们从对选择正确工具至关重要的每个维度对它们进行比较。

6## 概览

8| 方面 | Rust | Go |

9|------|------|-----|

10| **创建者** | Mozilla (2010) | Google (2009) |

11| **类型系统** | 静态、强类型、带所有权 | 静态、强类型、更简单 |

12| **内存管理** | 所有权 + 借用（无GC） | 垃圾回收器 |

13| **并发** | async/await、线程、通道 | Goroutines + 通道 |

14| **编译** | 较慢 | 非常快 |

15| **二进制大小** | 小、静态 | 小、静态 |

16| **学习曲线** | 陡峭 | 平缓 |

17| **错误处理** | Result/Option类型 | 多返回值 |

18| **空值安全** | 无null（Option类型） | 有nil |

19| **泛型** | 是（自1.0起） | 是（自1.18起） |

20~

21## 性能

22~

23Rust产生与C和C++相当的性能，没有垃圾回收器暂停。它让你完全控制内存布局和分配。

24~

25Go很快 - 比Python、JavaScript或Java快得多 - 但它有一个垃圾回收器，可能在性能关键的应用中引入延迟峰值。

26~

27```rust

28// Rust: Zero-cost abstractions

29fn sum_even(numbers: &[i32]) -> i32 {

30 numbers.iter()

31 .filter(|&&n| n % 2 == 0)

32 .sum()

33}

34```

35~

36```go

37// Go: Simple and clear

38func sumEven(numbers []int) int {

39 sum := 0

40 for _, n := range numbers {

41 if n%2 == 0 {

42 sum += n

43 }

44 }

45 return sum

46}

47```

48~

49两者都编译为原生代码。区别在于Rust的抽象（迭代器、闭包）编译为与手写循环相同的机器代码，而Go的简洁性有时意味着更少的优化潜力。

50~

51**选择Rust如果**：亚毫秒级延迟很重要（交易系统、游戏引擎、嵌入式）

52**选择Go如果**：吞吐量比延迟更重要（Web服务、CLI工具、DevOps）

53~

54## 内存安全

55~

56这是Rust的标志性特性。所有权系统在编译时捕获内存错误 - 没有空指针解引用、没有数据竞争、没有释放后使用。

57~

58```rust

59// Rust: This won't compile - ownership prevents use-after-free

60fn main() {

61 let s1 = String::from("hello");

62 let s2 = s1; // s1 is moved to s2

63 // println!("{}", s1); // ERROR: s1 is no longer valid

64 println!("{}", s2); // OK

65}

66```

67~

68```go

69// Go: nil can cause runtime panics

70func main() {

71 var s *string = nil

72 fmt.Println(*s) // PANIC at runtime: nil pointer dereference

73}

74```

75~

76Rust消除了Go（以及大多数其他语言）只能在运行时捕获的整类错误。

77~

78**选择Rust如果**：安全性至关重要（密码学、操作系统组件、浏览器）

79**选择Go如果**：垃圾回收器的安全保证对你的用例来说足够了

80~

81## 并发

82~

83两种语言都擅长并发，但方式截然不同。

84~

85### Go：Goroutines

86~

87Go的并发模型简单而优雅。Goroutines是由Go运行时管理的轻量级线程，通道支持它们之间的安全通信。

88~

89```go

90func fetchAll(urls []string) []string {

91 results := make(chan string, len(urls))

92~

93 for _, url := range urls {

94 go func(u string) {

95 resp, _ := http.Get(u)

96 body, _ := io.ReadAll(resp.Body)

97 results <- string(body)

98 }(url)

99 }

100~

101 var bodies []string

102 for range urls {

103 bodies = append(bodies, <-results)

104 }

105 return bodies

106}

107```

108~

109### Rust：async/await + Tokio

110~

111Rust的异步模型更复杂，但给你更多控制。编译器在编译时防止数据竞争。

112~

113```rust

114use tokio;

115use reqwest;

116~

117async fn fetch_all(urls: Vec<String>) -> Vec<String> {

118 let mut handles = vec![];

119~

120 for url in urls {

121 handles.push(tokio::spawn(async move {

122 reqwest::get(&url)

123 .await

124 .unwrap()

125 .text()

126 .await

127 .unwrap()

128 }));

129 }

130~

131 let mut results = vec![];

132 for handle in handles {

133 results.push(handle.await.unwrap());

134 }

135 results

136}

137```

138~

139**选择Go如果**：你想要简单、易于理解的并发

140**选择Rust如果**：你需要有保证的线程安全和零成本异步

141~

142## 开发者体验

143~

144### Go：简洁优先

145~

146Go被设计为简单的。语言规范只有几页。通常只有一种显而易见的做事方式。

147~

148- **编译速度快**：Go几乎瞬间编译

149- **内置齐全**：net/http、encoding/json、testing - 全部在标准库中

150- **gofmt**：一种格式化风格，没有争论

151- **容易学习**：Java/Python开发者可以在几天内上手

152~

153### Rust：强大但复杂

154~

155Rust更难学习，但以更多的表达力和安全性回报你。

156~

157- **编译较慢**：借用检查器和单态化需要时间

158- **Cargo**：优秀的包管理器和构建工具

159- **丰富的类型系统**：枚举、模式匹配、trait、泛型

160- **更陡的曲线**：所有权模型需要数周才能内化

161~

162```rust

163// Rust's expressive error handling

164fn parse_config(path: &str) -> Result<Config, ConfigError> {

165 let content = std::fs::read_to_string(path)

166 .map_err(ConfigError::IoError)?;

167~

168 let config: Config = serde_json::from_str(&content)

169 .map_err(ConfigError::ParseError)?;

170~

171 Ok(config)

172}

173```

174~

175```go

176// Go's straightforward error handling

177func parseConfig(path string) (*Config, error) {

178 content, err := os.ReadFile(path)

179 if err != nil {

180 return nil, fmt.Errorf("reading config: %w", err)

181 }

182~

183 var config Config

184 if err := json.Unmarshal(content, &config); err != nil {

185 return nil, fmt.Errorf("parsing config: %w", err)

186 }

187~

188 return &config, nil

189}

190```

191~

192## 生态系统和用例

193~

194### Go的优势领域

195~

196- **云基础设施**：Docker、Kubernetes、Terraform、Prometheus

197- **Web服务和API**：使用net/http或Gin/Fiber的快速HTTP服务器

198- **CLI工具**：cobra、urfave/cli

199- **DevOps工具**：大多数云原生工具都用Go编写

200- **微服务**：部署简单、二进制文件小、启动快

201~

202### Rust的优势领域

203~

204- **系统编程**：操作系统组件、驱动程序、嵌入式

205- **WebAssembly**：一流的WASM支持

206- **性能关键服务**：Cloudflare Workers、Discord的消息系统

207- **区块链**：Solana、Polkadot、许多加密项目

208- **游戏引擎**：Bevy引擎

209- **CLI工具**：ripgrep、bat、fd、starship

210~

211### 使用各语言的公司

212~

213| Go | Rust |

214|----|------|

215| Google (Kubernetes, gRPC) | Mozilla (Firefox) |

216| Docker | Cloudflare (Workers) |

217| Uber | Discord（消息存储） |

218| Twitch | Dropbox（文件同步） |

219| Hashicorp (Terraform) | AWS (Firecracker) |

220| Cloudflare | Microsoft（Windows组件） |

221~

222## 何时选择Go

223~

2241. **构建Web服务和API** - Go的简洁性和net/http使其非常理想

2252. **你的团队是系统编程新手** - Go的学习曲线更加平缓

2263. **你需要快速迭代** - Go瞬间编译，非常适合快速原型开发

2274. **DevOps和基础设施工具** - 生态系统无与伦比

2285. **微服务** - 小二进制文件、快速启动、简单部署

229~

230## 何时选择Rust

231~

2321. **性能不可妥协** - 零成本抽象、没有GC暂停

2332. **安全性至关重要** - 内存安全保证防止整类错误

2343. **WebAssembly** - 一流的WASM支持

2354. **嵌入式系统** - 无运行时、无GC、可预测的性能

2365. **替代C/C++** - 相同的性能加上内存安全

237~

238## 可以同时使用两者吗？

239~

240可以。许多组织同时使用两者：

241~

242- **Go** 用于Web服务、API和DevOps工具

243- **Rust** 用于性能关键的组件和库

244~

245它们可以通过FFI（外部函数接口）、gRPC或服务间的REST API进行互操作。

246~

247```mermaid

248graph LR

249 subgraph "Go Services"

250 API[API Gateway\nGo]

251 Auth[Auth Service\nGo]

252 end

253~

254 subgraph "Rust Services"

255 Search[Search Engine\nRust]

256 ML[ML Pipeline\nRust]

257 end

258~

259 API -- gRPC --> Search

260 API -- gRPC --> Auth

261 API -- gRPC --> ML

262```

263~

264## 总结

265~

266Go和Rust都是优秀的语言，但它们为不同的事物进行优化：

267~

268- **Go为简洁性优化** - 学习快、编译快、发布快

269- **Rust为正确性优化** - 安全、快速、表达力强，但更难学习

270~

271如果你正在构建Web服务、API或DevOps工具并想要快速前进，选择Go。如果你正在构建性能关键、安全关键或系统级别的软件，选择Rust。

272~

273最佳选择取决于你的团队、你的约束和你的优先级。两种语言在2026年及以后都会为你提供良好的服务。

274~