Rust程序设计

作者:[美]吉姆•布兰迪（Jim Blandy）

页数:476

译者:李松峰

出版时间:2020-9-12

价格:129

装帧:平装

isbn号码:9787115546494

丛书系列:图灵程序设计丛书

具体描述

本书由两位经验丰富的系统程序员撰写，介绍了一种具有C和C++性能，同时安全且支持并发的新型系统编程语言Rust，解释了Rust如何在性能和安全性之间架起桥梁，以及我们如何用好这门语言。书中主要内容包括：Rust的基本数据类型，关于所有权、引用等概念，表达式、错误处理、包和模块、结构体、枚举与模式等基础知识，Rust语言的特型与泛型，闭包，迭代器，集合，等等。

作者简介

吉姆•布兰迪（Jim Blandy）Mozilla软件工程师，拥有近40年编程经验和30年自由软件开发经验，是Subversion版本控制系统最初的设计者之一。

贾森•奥伦多夫（Jason Orendorff）资深软件工程师，拥有20余年软件开发经验，目前在为Mozilla Firefox Web浏览器开发JavaScript引擎。

目录信息

第 1 章 为什么是Rust 1
第 2 章　Rust初体验 5
2.1　下载和安装Rust 5
2.2　一个简单的函数 7
2.3　编写和运行单元测试 9
2.4　处理命令行参数 9
2.5　一个简单的Web服务器 13
2.6　并发 19
2.6.1　到底什么是曼德布洛特集合 19
2.6.2　解析成对的命令行参数 23
2.6.3　像素到复数的映射 25
2.6.4　绘制集合 26
2.6.5　写出图像文件 27
2.6.6　并发的曼德布洛特程序 29
2.6.7　运行曼德布洛特绘图器 32
2.6.8　安全无形 34
第 3 章　基本类型 35
3.1　机器类型 38
3.1.1　整数类型 38
3.1.2　浮点类型 40
3.1.3　布尔类型 42
3.1.4　字符类型 43
3.2　元组 44
3.3　指针类型 45
3.3.1　引用 46
3.3.2　Box 46
3.3.3　原始指针 46
3.4　数组、向量和切片 47
3.4.1　数组 47
3.4.2　向量 48
3.4.3　逐个元素地构建向量 51
3.4.4　切片 51
3.5　字符串类型 52
3.5.1　字符串字面量 52
3.5.2　字节字符串 53
3.5.3　字符串在内存中的表示 53
3.5.4　字符串 55
3.5.5　使用字符串 56
3.5.6　其他类似字符串的类型 56
3.6　更多类型 57
第 4 章　所有权 58
4.1　所有权 59
4.2　转移 63
4.2.1　更多转移操作 68
4.2.2　转移与控制流 69
4.2.3　转移与索引内容 69
4.3　Copy类型：转移的例外 71
4.4　Rc和Arc：共享所有权 74
第 5 章　引用 76
5.1　引用作为值 79
5.1.1　Rust引用与C++引用 79
5.1.2　给引用赋值 80
5.1.3　引用的引用 81
5.1.4　比较引用 81
5.1.5　引用永远不为空 82
5.1.6　借用对任意表达式的引用 82
5.1.7　对切片和特型对象的引用 83
5.2　引用安全 83
5.2.1　借用局部变量 83
5.2.2　接收引用作为参数 86
5.2.3　将引用作为参数传递 87
5.2.4　返回引用 88
5.2.5　结构体包含引用 89
5.2.6　不同的生命期参数 91
5.2.7　省略生命期参数 92
5.3　共享与修改 93
5.4　征服对象之海 99
第 6 章　表达式 101
6.1　表达式语言 101
6.2　块与分号 102
6.3　声明 103
6.4　if与match 105
6.5　循环 107
6.6　return表达式 109
6.7　为什么Rust有循环 110
6.8　函数与方法调用 111
6.9　字段与元素 112
6.10　引用操作符 113
6.11　算术、位、比较和逻辑操作符 113
6.12　赋值 114
6.13　类型转换 114
6.14　闭包 115
6.15　优先级与关联性 116
6.16　展望 118
第 7 章　错误处理 119
7.1　诧异 119
7.1.1　展开栈 120
7.1.2　中止进程 121
7.2　结果 121
7.2.1　捕获错误 121
7.2.2　结果类型别名 123
7.2.3　打印错误 123
7.2.4　传播错误 124
7.2.5　处理多种错误类型 125
7.2.6　处理“不会发生”的错误 127
7.2.7　忽略错误 128
7.2.8　在main()中处理错误 128
7.2.9　声明自定义错误类型 129
7.2.10　为什么是结果 130
第 8 章　包和模块 131
8.1　包 131
8.2　模块 134
8.2.1　把模块写在单独的文件中 135
8.2.2　路径和导入 136
8.2.3　标准前置模块 138
8.2.4　特性项，Rust的基础 139
8.3　将程序作为库发布 141
8.4　src/bin目录 142
8.5　属性 143
8.6　测试和文档 145
8.6.1　集成测试 147
8.6.2　文档 148
8.6.3　文档测试 149
8.7　指定依赖 152
8.7.1　版本 152
8.7.2　Cargo.lock 153
8.8　把包发布到crates.io 154
8.9　工作空间 156
8.10　还有惊喜 156
第 9 章　结构体 158
9.1　命名字段结构体 158
9.2　类元组结构体 161
9.3　类基元结构体 161
9.4　结构体布局 162
9.5　通过impl定义方法 162
9.6　泛型结构体 165
9.7　带生命期参数的结构体 167
9.8　为结构体类型派生共有特型 168
9.9　内部修改能力 168
第 10 章　枚举与模式 172
10.1　枚举 173
10.1.1　包含数据的枚举 175
10.1.2　枚举的内存布局 176
10.1.3　使用枚举的富数据结构 176
10.1.4　泛型枚举 178
10.2　模式 180
10.2.1　模式中的字面量、变量和通配符 183
10.2.2　元组与结构体模式 184
10.2.3　引用模式 185
10.2.4　匹配多种可能性 187
10.2.5　模式护具 188
10.2.6　@模式 188
10.2.7　在哪里使用模式 189
10.2.8　填充二叉树 190
10.3　设计的考量 191
第 11 章　特型与泛型 192
11.1　使用特型 193
11.1.1　特型目标 194
11.1.2　特型目标布局 195
11.1.3　泛型函数 196
11.1.4　使用哪一个 199
11.2　定义和实现特型 200
11.2.1　默认方法 201
11.2.2　特型与其他人的类型 202
11.2.3　特型中的Self 204
11.2.4　子特型 205
11.2.5　静态方法 205
11.3　完全限定方法调用 207
11.4　定义类型关系的特型 208
11.4.1　关联类型（或迭代器工作原理） 208
11.4.2　泛型特型（或操作符重载的原理） 211
11.4.3　伴型特型（或rand::random()工作原理） 212
11.5　逆向工程绑定 213
11.6　小结 216
第 12 章　操作符重载 217
12.1　算术与位操作符 218
12.1.1　一元操作符 220
12.1.2　二元操作符 221
12.1.3　复合赋值操作符 221
12.2　相等测试 222
12.3　顺序比较 225
12.4　Index与IndexMut 227
12.5　其他操作符 229
第 13 章　实用特型 230
13.1　Drop 231
13.2　Sized 233
13.3　Clone 235
13.4　Copy 236
13.5　Deref与DerefMut 237
13.6　Default 239
13.7　AsRef与AsMut 241
13.8　Borrow与BorrowMut 242
13.9　From与Into 244
13.10　ToOwned 245
13.11　Borrow与ToOwned实例：谦逊的奶牛（Cow） 246
第 14 章　闭包 248
14.1　捕获变量 249
14.1.1　借用值的闭包 250
14.1.2　盗用值的闭包 250
14.2　函数与闭包类型 252
14.3　闭包的性能 254
14.4　闭包和安全 255
14.4.1　杀值的闭包 255
14.4.2　FnOnce 256
14.4.3　FnMut 257
14.5　回调 259
14.6　有效使用闭包 261
第 15 章　迭代器 263
15.1　Iterator和IntoIterator特型 264
15.2　创建迭代器 265
15.2.1　iter和iter_mut方法 265
15.2.2　IntoIterator实现 266
15.2.3　drain方法 268
15.2.4　其他迭代器源 268
15.3　迭代器适配器 269
15.3.1　map和filter 269
15.3.2　filter_map和flat_map 271
15.3.3　scan 273
15.3.4　take和take_while 274
15.3.5　skip和skip_while 274
15.3.6　peekable 275
15.3.7　fuse 276
15.3.8　可逆迭代器与rev 277
15.3.9　inspect 278
15.3.10　chain 278
15.3.11　enumerate 279
15.3.12　zip 279
15.3.13　by_ref 280
15.3.14　cloned 281
15.3.15　cycle 281
15.4　消费迭代器 282
15.4.1　简单累计：count、sum和product 282
15.4.2　max和min 283
15.4.3　max_by和min_by 283
15.4.4　max_by_key和min_by_key 283
15.4.5　比较项序列 284
15.4.6　any和all 285
15.4.7　position、rposition和ExactSizeIterator 285
15.4.8　fold 285
15.4.9　nth 286
15.4.10　last 286
15.4.11　find 287
15.4.12　构建集合：collect和FromIterator 287
15.4.13　Extend特型 289
15.4.14　partition 289
15.5　实现自己的迭代器 290
第 16 章　集合 294
16.1　概述 295
16.2　Vec 296
16.2.1　访问元素 296
16.2.2　迭代 298
16.2.3　增长和收缩向量 298
16.2.4　连接 300
16.2.5　拆分 301
16.2.6　交换 303
16.2.7　排序和搜索 303
16.2.8　比较切片 304
16.2.9　随机元素 305
16.2.10　Rust排除无效错误 305
16.3　VecDeque 306
16.4　LinkedList 307
16.5　BinaryHeap 308
16.6　HashMap和BTreeMap 309
16.6.1　条目 311
16.6.2　映射迭代 313
16.7　HashSet和BTreeSet 313
16.7.1　集迭代 314
16.7.2　相等的值不相同 314
16.7.3　整集操作 315
16.8　散列 316
16.9　标准集合之外 318
第 17 章　字符串与文本 319
17.1　Unicode背景知识 319
17.1.1　ASCII、Latin-1和Unicode 320
17.1.2　UTF-8 320
17.1.3　文本方向性 322
17.2　字符（char） 322
17.2.1　字符分类 322
17.2.2　处理数字 322
17.2.3　字符大小写转换 323
17.2.4　与整数相互转换 324
17.3　String与str 324
17.3.1　创建字符串值 325
17.3.2　简单检查 325
17.3.3　追加和插入文本 326
17.3.4　删除文本 327
17.3.5　搜索与迭代的约定 327
17.3.6　搜索文本的模式 328
17.3.7　搜索与替换 328
17.3.8　迭代文本 329
17.3.9　修剪 331
17.3.10　字符串大小写转换 331
17.3.11　从字符串解析出其他类型 331
17.3.12　将其他类型转换为字符串 332
17.3.13　作为其他类文本类型借用 333
17.3.14　访问UTF-8格式的文本 333
17.3.15　从UTF-8数据产生文本 334
17.3.16　阻止分配 335
17.3.17　字符串作为泛型集合 336
17.4　格式化值 337
17.4.1　格式化文本值 338
17.4.2　格式化数值 339
17.4.3　格式化其他类型 341
17.4.4　为调试格式化值 341
17.4.5　为调试格式化指针 342
17.4.6　通过索引或名字引用参数 342
17.4.7　动态宽度与精度 343
17.4.8　格式化自定义类型 344
17.4.9　在你的代码中使用格式化语言 345
17.5　正则表达式 346
17.5.1　基本用法 347
17.5.2　懒构建Regex值 348
17.6　规范化 349
17.6.1　规范化形式 350
17.6.2　unicode-normalization包 351
第 18 章　输入和输出 352
18.1　读取器和写入器 353
18.1.1　读取器 354
18.1.2　缓冲读取器 355
18.1.3　读取文本行 356
18.1.4　收集行 358
18.1.5　写入器 359
18.1.6　文件 360
18.1.7　搜寻 360
18.1.8　其他读取器和写入器类型 361
18.1.9　二进制数据、压缩与序列化 362
18.2　文件与目录 364
18.2.1　OsStr和Path 364
18.2.2　Path和PathBuf的方法 365
18.2.3　文件系统访问函数 367
18.2.4　读取目录 368
18.2.5　平台特定的特性 369
18.3　网络编程 370
第 19 章　并发 373
19.1　并行分叉–合并 374
19.1.1　产生及合并 376
19.1.2　跨线程错误处理 377
19.1.3　跨线程共享不可修改数据 378
19.1.4　Rayon 380
19.1.5　重温曼德布洛特集合 382
19.2　通道 383
19.2.1　发送值 385
19.2.2　接收值 387
19.2.3　运行管道 388
19.2.4　通道特性与性能 390
19.2.5　线程安全：Send与Sync 391
19.2.6　将所有迭代器都接到通道上 393
19.2.7　超越管道 394
19.3　共享可修改状态 395
19.3.1　什么是互斥量 395
19.3.2　Mutex 397
19.3.3　mut与Mutex 398
19.3.4　互斥量的问题 399
19.3.5　死锁 399
19.3.6　中毒的互斥量 400
19.3.7　使用互斥量的多消费者通道 400
19.3.8　读/写锁（RwLock） 401
19.3.9　条件变量（Condvar）402
19.3.10　原子类型 403
19.3.11　全局变量 404
19.4　习惯编写Rust并发代码 406
第 20 章　宏 407
20.1　宏基础 408
20.1.1　宏扩展基础 409
20.1.2　意外结果 410
20.1.3　重复 411
20.2　内置宏 413
20.3　调试宏 414
20.4　json!宏 415
20.4.1　片段类型 416
20.4.2　在宏里使用递归 419
20.4.3　在宏里使用特型 419
20.4.4　作用域与自净宏 421
20.4.5　导入和导出宏 424
20.5　匹配时避免语法错误 425
20.6　超越macro_rules! 426
第 21 章　不安全代码 427
21.1　不安全源自哪里 428
21.2　不安全的块 429
21.3　不安全的函数 431
21.4　不安全的块还是不安全的函数 433
21.5　未定义行为 434
21.6　不安全的特型 435
21.7　原始指针 437
21.7.1　安全解引用原始指针 439
21.7.2　示例：RefWithFlag 440
21.7.3　可空指针 442
21.7.4　类型大小与对齐 442
21.7.5　指针算术 443
21.7.6　移入和移出内存 444
21.7.7　示例：GapBuffer 447
21.7.8　不安全代码中的诧异安全性 453
21.8　外来函数：在Rust中调用C和C++ 453
21.8.1　查找共有数据表示 454
21.8.2　声明外来函数和变量 456
21.8.3　使用库函数 458
21.8.4　libgit2的原始接口 461
21.8.5　libgit2的安全接口 466
21.9　小结 475
作者介绍 476
封面介绍 476
· · · · · · (收起)

用户评价

这本书的封面设计充满了现代感，那种深邃的蓝色和简洁的排版，让人一眼就能感觉到它传递出的专业和严谨。我之所以选择它，很大程度上是因为我对这门语言的未来发展抱有极大的期待，它在系统编程、高性能计算以及WebAssembly领域的潜力令人兴奋。刚翻开第一章，作者的行文风格就展现出一种令人信赖的沉稳，没有故作高深的晦涩术语，而是用一种近乎讲故事的方式，将复杂的内存管理和所有权系统娓娓道来。这对于初学者来说简直是福音，它没有上来就用大量的语法规则轰炸读者，而是先建立起一个清晰的认知框架。比如，在讲解生命周期的时候，作者并没有直接堆砌宏（macro）和生命周期注解（lifetime annotations），而是通过几个精心构建的小例子，生动地展示了数据如何在不同作用域内安全地存活和消亡，那种豁然开朗的感觉是其他很多技术书籍难以给予的。特别是关于并发模型的阐述，作者的处理方式极其巧妙，将`Send`和`Sync`这些抽象的概念，通过具体的代码场景进行具象化，让人深刻理解了Rust是如何在编译期就杜绝数据竞争这个“老大难”问题的。这本书的排版也值得称赞，代码块和关键概念的突出显示做得恰到好处，即便是在长时间阅读后，眼睛的疲劳感也比阅读其他同类书籍要轻得多。总而言之，这本书为我打开了一扇通往安全、高性能编程世界的大门，它的结构设计和讲解深度，完全符合我对一本优秀技术专著的期待。

我通常对技术书籍的评价标准非常苛刻，尤其是涉及底层机制和底层语言特性的书籍，如果不能在理论深度和工程实践之间找到一个完美的平衡点，那么很快就会沦为“只可远观不可亵玩”的摆设。然而，这本书在这一点上做得非常出色。它并没有止步于介绍Rust的语法糖，而是深入剖析了其背后的LLVM优化策略和零成本抽象的哲学。例如，在讨论Trait对象（Trait Objects）时，书中不仅解释了动态分发（Dynamic Dispatch）的原理和性能开销，还详细对比了它与静态分发（Static Dispatch）在不同场景下的适用性，甚至还涉及了虚函数表（vtable）的内存布局。这种对底层细节的毫不回避，极大地满足了我作为一个有一定编程经验的读者的求知欲。更令人印象深刻的是，书中对“Unsafe Rust”的探讨部分。作者没有将其视为洪水猛兽，而是以一种负责任的态度，系统地讲解了何时、为何需要使用`unsafe`，以及如何最小化其使用范围并结合外部的保证（Invariants）来确保程序的整体安全性。这体现了作者深厚的工程素养——技术是用来解决问题的，而不是用来束缚思维的。阅读过程中，我时不时会停下来，手动用纸笔推导一下书中给出的复杂泛型实例化过程，发现作者的逻辑链条是如此严密，几乎找不到可供质疑的逻辑漏洞。这本书无疑是一部扎实的参考手册，更像是一位资深工程师在耳边进行的系统性辅导。

我是一个典型的“重度实践、轻度理论”的学习者，我的耐心往往在冗长、过于学院派的理论阐述面前迅速耗尽。因此，我通常会先在网上找一些快速入门的教程来建立基本概念，然后再寻找一本能够提供深度和广度的权威参考书。这本书恰好填补了我寻找权威参考书的这个需求空缺。它在对语言核心概念的挖掘深度上，达到了近乎于语言规范的级别，但语言风格却异常地平易近人。我注意到，书中对于泛型约束（Trait Bounds）的讲解，深入到了类型擦除（Type Erasure）和单态化（Monomorphization）的本质区别，这对于理解编译期优化至关重要。很多其他书籍仅仅停留在“如何写出泛型代码”的层面，而这本书则让你明白了“编译器是如何处理你的泛型代码”的。此外，作者对标准库中一些不常用但功能强大的模块，例如`std::mem`下的内存操作函数，也给予了应有的关注，并配以必要的安全警告。这表明作者的视野并未局限于最热门的Web或CLI应用场景，而是对整个语言体系都有一个全面的覆盖。这本书更像是一部“内功心法”的秘籍，它不会直接教你招式，但一旦你掌握了书中的原理，你在面对任何新的框架或新版本的语言特性时，都能迅速洞察其本质，并举一反三。它是我书架上那些会被我反复翻阅，而不是读完一遍就束之高阁的技术著作之一。

说实话，市面上关于新兴语言的书籍多如牛毛，但真正能把“生态”和“社区”融入技术讲解的却凤毛麟角。这本书的高明之处在于，它不仅仅是一本关于语言本身的教科书，更像是为你准备了一张进入Rust开发世界的导航图。它没有忽视那些在实际工作中至关重要的工具链和周边生态。比如，关于Cargo的使用，书中不仅讲了基本的构建和依赖管理，还深入探讨了工作区（Workspaces）的配置、发布到crates.io的流程，甚至还提到了如何编写自定义的build.rs脚本来处理复杂的外部依赖链接问题。这些细节在很多“入门”书籍中是完全被跳过的，但正是这些细节，构成了日常开发中的关键痛点。此外，书中对于异步编程（Async/Await）部分的讲解，也展现了对当前主流框架的深刻理解。作者没有停留在标准库的描述上，而是花了大量篇幅来比较Tokio、async-std等运行时（Runtime）的差异和设计哲学，以及Future的拉取机制。这种将语言特性与主流应用场景紧密结合的处理方式，使得书中的知识点具备了极强的可迁移性和实用价值。读完相关章节，我立刻就能着手去改造我现有的网络服务项目，而不是停留在“我知道了如何使用async/await”的空泛层面。这种“立即可用”的知识输出，是衡量一本优秀技术书的关键指标。

这本书的叙事节奏和内容组织，完全打破了我对传统技术书籍那种“堆砌知识点”的刻板印象。它似乎更偏向于一种“项目驱动”的学习体验。每一章的知识点都不是孤立存在的，而是围绕着一个或多个不断演进的实践案例逐步展开的。例如，在讲解错误处理时，它不是简单地罗列`Result`和`Option`，而是设计了一个从简单的`panic!`到使用`thiserror`和`anyhow`构建复杂错误链条的演进过程。这种层层递进的结构，极大地降低了读者的认知负担，让你感觉自己是在“构建”一个程序，而不是在“学习”一种语法。我个人特别欣赏作者在处理复杂抽象时所采取的“先求对，再求精”的策略。比如，在介绍宏系统时，作者非常巧妙地利用了过程宏（Procedural Macros）作为切入点，而不是一开始就陷入过程宏和声明宏（Declarative Macros）的繁琐细节中，这保证了读者不会在最初就被晦涩的元编程概念劝退。书中的插图和图示质量也达到了专业级别，它们精确地描绘了数据流和内存布局，清晰度远超许多网络上的教程截图。总而言之，阅读这本书的过程，就像是在一位经验丰富的导师的指导下，一步步完成一个复杂但结构清晰的软件模块的构建，收获的不仅仅是知识，更是解决问题的信心和架构思维。

比官方出的那本好

不止教授 Rust 开发过程，对核心原理也有深入阐述，更进一步的是有与其他语言在设计哲学上的对比，值得反复阅读

就算这本书名词的翻译很奇怪，内容些许过时，这本书也是现在能买到的学习Rust最好的书。

神书，起于rust，终于编程思想、操作系统、语法设计，aha time 很频繁。

非常精彩，翻译顺畅，内容逻辑清晰