首页 > 科技 > 计算机 > 编程语言

Rust编程之道

作译者：张汉东

出版时间：2019-01 千字数：1018 版次：01-01 页数：580

开本：16开装帧： I S B N ：9787121354854

换版：

纸质书定价：￥128.0

库存:有

分享到：

共有图书评论0条【查看评论摘要】

看了又看

{{data.bookName}}

￥{{data.price}}

内容简介

前言

上架建议

作者简介

编辑推荐

音视频专区

第1 章 新时代的语言 .................................................................................................. 1
1.1 缘起 ........................................................................................................................... 1
1.2 设计哲学 ................................................................................................................... 3
1.2.1 内存安全....................................................................................................... 3
1.2.2 零成本抽象 ................................................................................................... 4
1.2.3 实用性 .......................................................................................................... 5
1.3 现状与未来 ............................................................................................................... 7
1.3.1 语言架构....................................................................................................... 8
1.3.2 开源社区....................................................................................................... 9
1.3.3 发展前景....................................................................................................... 9
1.4 Rust 代码如何执行 ................................................................................................ 10
1.5 小结 ......................................................................................................................... 10
第2 章 语言精要 ........................................................................................................ 11
2.1 Rust 语言的基本构成 ............................................................................................. 11
2.1.1 语言规范..................................................................................................... 11
2.1.2 编译器 ........................................................................................................ 12
2.1.3 核心库 ........................................................................................................ 12
2.1.4 标准库 ........................................................................................................ 12
2.1.5 包管理器..................................................................................................... 13
2.2 语句与表达式 ......................................................................................................... 13
2.3 变量与绑定 ............................................................................................................. 14
2.3.1 位置表达式和值表达式 ............................................................................. 15
2.3.2 不可变绑定与可变绑定 ............................................................................. 15
2.3.3 所有权与引用 ............................................................................................. 16
2.4 函数与闭包 ............................................................................................................. 17
2.4.1 函数定义..................................................................................................... 17
2.4.2 作用域与生命周期 ..................................................................................... 18
2.4.3 函数指针..................................................................................................... 19
2.4.5 CTFE 机制 .................................................................................................. 20
2.4.6 闭包 ............................................................................................................ 20
2.5 流程控制 ................................................................................................................. 22
2.5.1 条件表达式 ................................................................................................. 22
2.5.2 循环表达式 ................................................................................................. 23
2.5.3 match 表达式与模式匹配 .......................................................................... 24
2.5.4 if let 和while let 表达式 ............................................................................ 25
2.6 基本数据类型 ......................................................................................................... 26
2.6.1 布尔类型..................................................................................................... 26
2.6.2 基本数字类型 ............................................................................................. 26
2.6.3 字符类型..................................................................................................... 27
2.6.4 数组类型..................................................................................................... 28
2.6.5 范围类型..................................................................................................... 29
2.6.6 切片类型..................................................................................................... 29
2.6.7 str 字符串类型 ............................................................................................ 30
2.6.8 原生指针..................................................................................................... 31
2.6.9 never 类型 ................................................................................................... 31
2.7 复合数据类型 ......................................................................................................... 32
2.7.1 元组 ............................................................................................................ 32
2.7.2 结构体 ........................................................................................................ 33
2.7.3 枚举体 ........................................................................................................ 36
2.8 常用集合类型 ......................................................................................................... 38
2.8.1 线性序列：向量 ......................................................................................... 38
2.8.2 线性序列：双端队列 ................................................................................. 39
2.8.3 线性序列：链表 ......................................................................................... 40
2.8.4 Key-Value 映射表：HashMap 和BTreeMap ............................................ 40
2.8.5 集合：HashSet 和BTreeSet ...................................................................... 41
2.8.6 优先队列：BinaryHeap ............................................................................. 42
2.9 智能指针 ................................................................................................................. 42
2.10 泛型和trait ........................................................................................................... 43
2.10.1 泛型 .......................................................................................................... 43
2.10.2 trait ............................................................................................................ 44
2.11 错误处理 ............................................................................................................... 47
2.12 表达式优先级 ....................................................................................................... 48
2.13 注释与打印 ........................................................................................................... 48
2.14 小结 ....................................................................................................................... 50
第3 章 类型系统 ........................................................................................................ 51
3.1 通用概念 ................................................................................................................. 51
3.1.1 类型系统的作用 ......................................................................................... 51
3.1.2 类型系统的分类 ......................................................................................... 52
3.1.3 类型系统与多态性 ..................................................................................... 53
3.2 Rust 类型系统概述 ................................................................................................ 53
3.2.1 类型大小..................................................................................................... 53
3.2.2 类型推导..................................................................................................... 58
3.3 泛型 ......................................................................................................................... 60
3.3.1 泛型函数..................................................................................................... 60
3.3.2 泛型返回值自动推导 ................................................................................. 62
3.4 深入trait ................................................................................................................. 62
3.4.1 接口抽象..................................................................................................... 63
3.4.2 泛型约束..................................................................................................... 69
3.4.3 抽象类型..................................................................................................... 71
3.4.4 标签trait ..................................................................................................... 77
3.5 类型转换 ................................................................................................................. 83
3.5.1 Deref 解引用 .............................................................................................. 83
3.5.2 as 操作符 .................................................................................................... 86
3.5.3 From 和Into ............................................................................................... 88
3.6 当前trait 系统的不足 ............................................................................................ 89
3.6.1 孤儿规则的局限性 ..................................................................................... 90
3.6.2 代码复用的效率不高 ................................................................................. 91
3.6.3 抽象表达能力有待改进 ............................................................................. 93
3.7 小结 ......................................................................................................................... 94
第4 章 内存管理 ........................................................................................................ 95
4.1 通用概念 ................................................................................................................. 95
4.1.1 栈 ................................................................................................................ 96
4.1.2 堆 ................................................................................................................ 99
4.1.3 内存布局................................................................................................... 101
4.2 Rust 中的资源管理 ...............................................................................................103
4.2.1 变量和函数 ............................................................................................... 103
4.2.2 智能指针与RAII ..................................................................................... 106
4.2.3 内存泄漏与内存安全 ............................................................................... 110
4.2.4 复合类型的内存分配和布局 ................................................................... 115
4.3 小结 ........................................................................................................................ 117
第5 章 所有权系统 .................................................................................................. 119
5.1 通用概念 ................................................................................................................120
5.2 所有权机制 ............................................................................................................123
5.3 绑定、作用域和生命周期 ....................................................................................125
5.3.1 不可变与可变 ........................................................................................... 126
5.3.2 绑定的时间属性——生命周期 ............................................................... 127
5.4 所有权借用 ............................................................................................................131
5.5 生命周期参数 ........................................................................................................135
5.5.1 显式生命周期参数 ................................................................................... 136
5.5.2 省略生命周期参数 ................................................................................... 143
5.5.3 生命周期限定 ........................................................................................... 145
5.5.4 trait 对象的生命周期 ............................................................................... 145
5.6 智能指针与所有权 ................................................................................................146
5.6.1 共享所有权 Rc＜T＞和Weak＜T＞ ............................................................ 149
5.6.2 内部可变性Cell＜T＞和RefCell＜T＞ ........................................................ 151
5.6.3 写时复制Cow＜T＞ ................................................................................... 153
5.7 并发安全与所有权 ................................................................................................156
5.8 非词法作用域生命周期 ........................................................................................157
5.9 小结 ........................................................................................................................161
第6 章 函数、闭包与迭代器.................................................................................... 162
6.1 函数 ........................................................................................................................162
6.1.1 函数屏蔽................................................................................................... 164
6.1.2 函数参数模式匹配 ................................................................................... 164
6.1.3 函数返回值 ............................................................................................... 165
6.1.4 泛型函数................................................................................................... 166
6.1.5 方法与函数 ............................................................................................... 167
6.1.6 高阶函数................................................................................................... 168
6.2 闭包 ........................................................................................................................171
6.2.1 闭包的基本语法 ....................................................................................... 172
6.2.2 闭包的实现 ............................................................................................... 173
6.2.3 闭包与所有权 ........................................................................................... 178
6.2.4 闭包作为函数参数和返回值 ................................................................... 184
6.2.5 高阶生命周期 ........................................................................................... 190
6.3 迭代器 ....................................................................................................................194
6.3.1 外部迭代器和内部迭代器 ....................................................................... 194
6.3.2 Iterator trait ............................................................................................... 195
6.3.3 IntoIterator trait 和迭代器 ........................................................................ 199
6.3.4 迭代器适配器 ........................................................................................... 202
6.3.5 消费器 ...................................................................................................... 207
6.3.6 自定义迭代器适配器 ............................................................................... 211
6.4 小结 ........................................................................................................................214
第7 章 结构化编程 .................................................................................................. 216
7.1 面向对象风格编程 ................................................................................................217
7.1.1 结构体 ...................................................................................................... 217
7.1.2 枚举体 ...................................................................................................... 225
7.1.3 析构顺序................................................................................................... 230
7.2 常用设计模式 ........................................................................................................233
7.2.1 建造者模式 ............................................................................................... 234
7.2.2 访问者模式 ............................................................................................... 236
7.2.3 RAII 模式 ................................................................................................. 239
7.3 小结 ........................................................................................................................243
第8 章 字符串与集合类型 ....................................................................................... 244
8.1 字符串 ....................................................................................................................244
8.1.1 字符编码................................................................................................... 244
8.1.2 字符 .......................................................................................................... 247
8.1.3 字符串分类 ............................................................................................... 249
8.1.4 字符串的两种处理方式 ........................................................................... 251
8.1.5 字符串的修改 ........................................................................................... 253
8.1.6 字符串的查找 ........................................................................................... 256
8.1.7 与其他类型相互转换 ............................................................................... 265
8.1.8 回顾 .......................................................................................................... 270
8.2 集合类型 ................................................................................................................271
8.2.1 动态可增长数组 ....................................................................................... 271
8.2.2 映射集 ...................................................................................................... 281
8.3 理解容量 ................................................................................................................289
8.4 小结 ........................................................................................................................292
第9 章 构建健壮的程序 ........................................................................................... 294
9.1 通用概念 ................................................................................................................294
9.2 消除失败 ................................................................................................................295
9.3 分层处理错误 ........................................................................................................297
9.3.1 可选值Option＜T＞ .................................................................................... 298
9.3.2 错误处理Result＜T, E＞ ............................................................................ 302
9.4 恐慌（Panic） .......................................................................................................314
9.5 第三方库 ................................................................................................................316
9.6 小结 ........................................................................................................................319
第10 章 模块化编程 ................................................................................................ 320
10.1 包管理 ..................................................................................................................321
10.1.1 使用Cargo 创建包 ................................................................................. 321
10.1.2 使用第三方包 ......................................................................................... 323
10.1.3 Cargo.toml 文件格式 .............................................................................. 331
10.1.4 自定义Cargo .......................................................................................... 337
10.2 模块系统 ..............................................................................................................339
10.3 从零开始实现一个完整功能包 ..........................................................................344
10.3.1 使用Cargo 创建新项目 ......................................................................... 345
10.3.2 使用structopt 解析命令行参数 ............................................................. 345
10.3.3 定义统一的错误类型 ............................................................................. 347
10.3.4 读取CSV 文件 ....................................................................................... 348
10.3.5 替换CSV 文件中的内容 ....................................................................... 351
10.3.6 进一步完善包 ......................................................................................... 353
10.4 可见性和私有性 ..................................................................................................358
10.5 小结 ......................................................................................................................360
第11 章 安全并发 .................................................................................................... 362
11.1 通用概念 ..............................................................................................................362
11.1.1 多进程和多线程 ..................................................................................... 363
11.1.2 事件驱动、异步回调和协程 ................................................................. 364
11.1.3 线程安全 ................................................................................................. 365
11.2 多线程并发编程 ..................................................................................................370
11.2.1 线程管理 ................................................................................................. 371
11.2.2 Send 和Sync ........................................................................................... 375
11.2.3 使用锁进行线程同步 ............................................................................. 379
11.2.4 屏障和条件变量 ..................................................................................... 384
11.2.5 原子类型 ................................................................................................. 386
11.2.6 使用Channel 进行线程间通信 .............................................................. 388
11.2.7 内部可变性探究 ..................................................................................... 397
11.2.8 线程池 ..................................................................................................... 399
11.2.9 使用Rayon 执行并行任务 .................................................................... 407
11.2.10 使用Crossbeam .................................................................................... 409
11.3 异步并发 ..............................................................................................................412
11.3.1 生成器 ..................................................................................................... 413
11.3.2 Future 并发模式 ..................................................................................... 418
11.3.3 async/await .............................................................................................. 421
11.4 数据并行 ..............................................................................................................428
11.4.1 什么是SIMD .......................................................................................... 429
11.4.2 在Rust 中使用SIMD............................................................................. 430
11.5 小结 ......................................................................................................................434
第12 章 元编程 ....................................................................................................... 435
12.1 反射 ......................................................................................................................436
12.1.1 通过is 函数判断类型 ............................................................................ 436
12.1.2 转换到具体类型 ..................................................................................... 437
12.1.3 非静态生命周期类型 ............................................................................. 439
12.2 宏系统 ..................................................................................................................440
12.2.1 起源 ........................................................................................................ 440
12.2.2 Rust 中宏的种类 .................................................................................... 441
12.2.3 编译过程 ................................................................................................. 442
12.2.4 声明宏 .................................................................................................... 445
12.2.5 过程宏 .................................................................................................... 458
12.3 编译器插件 ..........................................................................................................472
12.4 小结 ......................................................................................................................475
第13 章 超越安全的边界 ......................................................................................... 477
13.1 Unsafe Rust 介绍 .................................................................................................477
13.1.1 Unsafe 语法 ............................................................................................ 478
13.1.2 访问和修改可变静态变量 ..................................................................... 480
13.1.3 Union 联合体 .......................................................................................... 480
13.1.4 解引用原生指针 ..................................................................................... 483
13.2 基于Unsafe 进行安全抽象 .................................................................................484
13.2.1 原生指针 ................................................................................................. 484
13.2.2 子类型与型变 ......................................................................................... 489
13.2.3 未绑定生命周期 ..................................................................................... 494
13.2.4 Drop 检查 ............................................................................................... 495
13.2.5 NonNull＜T＞指针 .................................................................................... 505
13.2.6 Unsafe 与恐慌安全 ................................................................................ 508
13.2.7 堆内存分配 ............................................................................................. 508
13.2.8 混合代码内存安全架构三大原则 ......................................................... 510
13.3 和其他语言交互 ..................................................................................................510
13.3.1 外部函数接口 ......................................................................................... 510
13.3.2 与C/C++语言交互 ................................................................................. 514
13.3.3 使用Rust 提升动态语言性能 ............................................................... 528
13.4 Rust 与WebAssembly .........................................................................................532
13.4.1 WebAssembly 要点介绍......................................................................... 533
13.4.2 使用Rust 开发WebAssembly ............................................................... 539
13.4.3 打造WebAssembly 开发生态 ................................................................ 541
13.5 小结 ......................................................................................................................543
附录A Rust 开发环境指南 ....................................................................................... 544
附录B Rust 如何调试代码 ....................................................................................... 549

序
当我2015 年开始学习Rust 的时候，我绝对没有想过要写一本Rust 编程的书。
缘起
当时我刚刚翻译完《Ruby 原理剖析》一书，开始对底层开发产生了一点点兴趣。从2006年入行以来，我就一直和动态语言打交道。虽然自己也想学习底层开发，但能选择的语言几乎只有C++。我在学校里浅浅地学过C++这门语言，也许是第一印象作怪，总难以提起对C++的兴趣。
当Rust 1.0 发布时，我去官方网站了解了一下Rust 语言，发现它的主要特点有以下几方面：
? 系统级语言
? 无GC
? 基于LLVM
? 内存安全
? 强类型+静态类型
? 混合编程范式
? 零成本抽象
? 线程安全
我一下子就被这些鲜明的特性“击中”了，从此开始了Rust 的学习。
再一次爱上编程
第一次爱上编程是在上小学时。父亲给我买回来一台金字塔学习机，这台学习机有两种功能，一种是学习Logo 语言，另一种是玩卡带游戏。编写Logo 语言就是用小海龟画图，也许是因为太早了，也许是因为没有人引导，那时的我选择了痛快地玩游戏。总想着先玩游戏，再去学怎么编程，然后还幻想着能不能用Logo 语言编写一个游戏。其实这时候的我对编程更多的是一种憧憬，并没有在学习编程上付出更多的实际行动。
第二次爱上编程是在大学初次学习C 语言的时候。我本可以选择计算机科学专业，但是最后还是选了电子信息科学与技术专业。这样选是因为我想把软硬件都学了。想法是好的，可惜实施起来并不容易。最后的结果就是，软硬件都没学好。
第三次爱上编程是在遇到Ruby 语言的时候。当时我在用Java，并且已经完全陷入了Java语言和Web 框架纷繁复杂的细节中，痛苦不堪。Ruby on Rails 框架的横空出世，把我从这种状态中解救了出来。Ruby 语言的优雅和自由，以及“让程序员更快乐”的口号深深地吸引了我。这一次我是真正爱上了编程，并且积极付诸行动去学习和提升自己。此时也恰逢互联网创业大潮的开始，Ruby 语言的开发效率让它迅速成为创业公司的宠儿，因此，我也借着Ruby
这门语言参与到了这股创业洪流中。
第四次爱上编程是在遇到Rust 的时候。此时，创业洪流已经退潮。技术圈有句话，叫“十年一轮回”。当年喜欢Ruby 给开发过程带来的快乐，但是随着时代的变革和业务规模的增长，我不禁开始重新思考一个问题：何谓快乐？真正的快乐不仅仅是写代码时的“酸爽”，更应该是代码部署到生产环境之后的“安稳”。Rust 恰恰可以给我带来这种“双重快乐”体验。
为什么是Rust
社区中有人模仿阿西莫夫的机器人三大定律，总结了程序的三大定律：
? 程序必须正确。
? 程序必须可维护，但不能违反第一条定律。
? 程序必须高效，但不能违反前两条定律。
程序的正确性，一方面可以理解为该程序满足了实际的问题需求，另一方面是指满足了它自身的程序规约。那么如何保证程序的正确性呢？首先，可以通过对程序的各种测试、断言和错误处理机制，来保证其满足实际的问题需求。其次，在数学和计算机科学已经融合的今天，通过较为成熟的类型理论即可保证程序自身的规约正确。
以我最熟悉的Ruby 语言为例，程序的正确性必须依赖于开发者的水平，并需要大量的测试代码来保证正确性。即便在100%测试覆盖率的条件下，也经常会遇到NilError 之类的空指针问题。也就是说，Ruby 程序自身的正确性还没有得到保证。以此类推，C、C++、Python、Java、JavaScript 等语言都有同样的问题。
而函数式编程语言在这方面要好很多，尤其是号称纯函数式的Haskell 语言，它具有融合了范畴理论的类型系统，利用了范畴理论自身的代数性质和定律保证了程序自身的正确性。然而，Haskell 也有比较明显的缺点，比如它不满足上述第三条定律，运行效率不高。
反观Rust 语言，对程序的三定律支持得恰到好处。它借鉴了Haskell 的类型系统，保证了程序的正确性。但还不止于此，在类型系统的基础上，Rust 借鉴了现代C++的内存管理机制，建立了所有权系统。不仅保证了类型安全，还保证了内存安全。同时，也解决了多线程并发编程中的数据竞争问题，默认线程安全。再来看代码的可维护性，Rust 代码的可读性和抽象能力都是一流的。不仅拥有高的开发效率，还拥有可以和C/C++媲美的性能。当然，没有银弹，但Rust 就是我目前想要的语言。
目前Rust 被陆续应用在区块链、游戏、WebAssembly 技术、机器学习、分布式数据库、网络服务基础设施、Web 框架、操作系统和嵌入式等领域。时代在变化，未来的互联网需要的是安全和性能并重的语言，Rust 必然会在其中大放异彩。
学习Rust 带来了什么收获
Rust 是一门现代化的语言，融合了多种语言特性，而且Rust 语言可以应用的领域范围非常广泛。在学习Rust 的过程中，我发现自己的编程能力在很多方面存在短板。突破这些短板的过程实际上就是一次自我提升的过程。
Rust 是一门成长中的新语言，学习Rust，跟随Rust 一起成长，可以体验并参与到一门真正工业化语言的发展进程中，感觉就像在创造历史。虽然我并未给Rust 语言提交过PR，但也为Rust 语言和社区多次提交过Bug，以及文档和工具的改进意见。
Rust 自身作为一个开源项目，算得上是开源社区中的“明星”项目了。学习Rust 的过程加深了我对开源社区的认识，也开拓了我的眼界。
为什么要写这本书
在学习Rust 一年之后，我写下了《如何学习一门新语言》一文，其中记录了我学习Rust的心得，这篇文章颇受好评。也正因为这篇文章，电子工业出版社的刘恩惠编辑找到了我，并询问是否可以出一本Rust 编程的书籍。我当时也正想通过一本书来完整地表达自己的学习心得，再加上中文社区中没有较全面系统的Rust 书籍，于是，一拍即合。
写书的过程可以形容为痛并快乐着。Rust 语言正值成长期，很多语言特性还在不断地完善。举一个极端的例子，比如写下某段代码示例并成功编译后，过了三天却发现它无法编译通过了。于是，我再一次跟进Rust 的RFC、源码、ChangeLog 去看它们的变更情况，然后再重新修订代码示例。这个过程虽然痛苦，但改完之后会发现Rust 的这个改进确实是有必要的。
在这个过程中，我看到了Rust 的成长，以及Rust 团队为保证语言一致性和开发者的开发体验所付出的努力，让我感觉自己花再多时间和精力去修改本书的内容都是值得的。
话说回来，任何人做事都是有动机或目的的，我也不例外。我写这本书的目的主要有以下三个。
? 为Rust 中文社区带来一本真正可以全面系统地学习Rust 的书。
? 以教为学。在写作的过程中，让自己所学的知识进一步内化。
? 传播一种自学方法。本书内容以Rust 语言的设计哲学为出发点，按照从整体到细节的思路逐个阐述每个语言特性，希望读者可以产生共鸣。
结语
我自己作为本书的第一位读者，目前对这本书是非常满意的。衷心希望每一位读者都能从本书中收获新知。当然，我也知道不可能让每一位读者都满意。在我看来，写书不仅是在传播知识和思想，更是一种交流和沟通。所以，当你不满意的时候，可以来找我交流，提出更多建设性意见，帮助我成长。我争取在写下一本书的时候，让更多的人满意。而且，如果你的建议确实中肯，让我得到了成长，我也为你准备了不错的小礼物。


前言
在我刚开始学习Rust 的时候，在社区里听到最多的声音就是“Rust 学习曲线陡”。已经有一定编程经验的人在学习一门新语言时，都喜欢直接上手写代码，因为这样可以快速体验这门语言的特色。对于大多数语言来说，这样确实可以达到一定的学习目的。但是当他们在初次学习Rust 的时候，就很难通过直接上手来体验这种快感。
我第一次学习Rust 时就遇到了这样的情况。我按以往的编程经验直接写下了代码，但是编译无法通过；可是有时候简单调换两行代码的顺序，程序就能顺利编译成功了，这让我非常困惑。我想这也是大多数人感觉“Rust 学习曲线陡”的原因吧。经过和Rust 编译器的多次“斗争”之后，我不得不重新反思自己的学习方法。看样子，Rust 编译器暗含了某种规则，只要程序员违反了这些规则，它就会检查出来并阻止你。这就意味着，作为程序员，你必须主动理解并遵守这些规则，编译器才能和你“化敌为友”。
所以，我就开始了对Rust 的第二轮学习，忘掉自己以往的所学，抱着初学者的心态，从零开始系统地学习Rust。然而，事情并没有这么简单。
Rust 官方虽然提供了Rust Book，但是内容的组织非常不友好，基本就是对知识点的罗列，系统性比较差。后来官方也意识到了这个问题，推出了第2 版的Rust Book，内容组织方面改善了很多，对学习者也非常友好，但系统性还是差了点。后来又看了国内Rust 社区组织群友们合著的Rust Primer，以及国外的Programming Rust，我才对Rust 建立了基本的认知体系。
直到此时，我才意识到一个重要的问题：Rust 学习曲线陡的根本原因在于Rust 语言融合了多种语言特性和多种编程范式。这就意味着，Rust 涉及的知识范围非常广泛，涵盖了面向对象、函数式、泛型、底层内存管理、类型系统、设计模式等知识。从底层到上层抽象，从模式到工程化健壮性，无所不包。可以说，Rust 是编程语言发展至今的集大成者。对于大多数Rust 语言的初学者来说，他掌握的知识体系范围是小于Rust 所包含的知识量的，所以在学习Rust 的过程中会遇到无法理解的内容。
我在学习Rust 之前，所掌握的编程语言知识体系大多是和拥有GC 的动态语言相关的，对于底层内存管理知之甚少。所以在我学习Rust 所有权的时候，就很难理解这种机制对于内存安全的意义所在；而我所认识的一些拥有C 语言编程经验的朋友，在学习Rust 时面临的问题是，难以理解Rust 支持的上层抽象，对他们来说，Rust 中融合的类型系统和编程范式就是他们学习道路上的“拦路虎”；对于拥有Haskell 等函数式编程经验的朋友，会感觉Rust的类型系统很容易理解，但是底层的内存管理和所有权机制又成了需要克服的学习障碍；来自C++编程圈的朋友，尤其是懂现代C++的朋友，对Rust 所有权机制理解起来几乎没有困难，但是类型系统和函数式编程范式可能会阻碍他们的学习。当然，如果正好你没有上述情况，那说明你的相关知识体系已经很全面了，你在Rust 的学习之路上将会非常顺利。
这是不是意味着，在学习Rust 之前需要把其他语言都学一遍呢？答案是否定的。
Rust 编程语言虽然融合了很多其他语言的特性和范式，但它不是进行简单的内容堆叠，而是有机地融合了它们。也就是说，Rust 遵循着高度的一致性内核来融合这些特性。我们只需要从Rust 的设计哲学出发，牢牢地把握它的设计一致性，就可以把它的所有特性都串起来，从而达到掌握它的目的。这正是本书遵循的写作逻辑。
本书特点
从设计哲学出发，探索Rust 语言的内在一致性。设计哲学是一门优秀编程语言保持语言一致性的关键所在。设计哲学是语言特性和语法要素设计的诱因和准则。理解Rust 语言的设计哲学，有助于把握Rust 语言的内核与一致性，把Rust 看似纷繁复杂的特性都系统地串起来。
从源码分析入手，探索Rust 地道的编程风格。Rust 是一门自举的语言，也就是说，Rust语言由Rust 自身实现。通过阅读Rust 标准库和一些第三方库的源码，不仅可以深入理解Rust提供的数据类型和数据结构，更能体验和学习地道的Rust 编程风格。
从工程角度着手，探索Rust 对健壮性的支持。Rust 通过类型系统、断言、错误处理等机制保证内存安全的同时，还保证了系统的健壮性。从工程角度去看 Rust，才能看到 Rust对系统健壮性的支持是多么优雅。
从底层原理开始，探索Rust 内存安全的本质。只有深入底层，才能理解Rust 所有权机制对于内存安全的意义。而且可以进一步理解Rust 的类型系统，以及Unsafe Rust 存在的必要性。
读者群体
适合本书的读者群体包括：
? 有一定编程经验，想要学习Rust 的初学者。
? 对Rust 有一定了解，还想对Rust 深入学习的进阶者。
本书不适合完全没有编程基础的人学习。
如何阅读本书
对于Rust 初学者，建议按照章节顺序去阅读。因为本书每一章内容基本都依赖于前一章内容的前置知识。
对于Rust 有一定了解的朋友，可以选择你感兴趣的章节去阅读。因为本书的每一章也是对一个垂直主题的深入探讨。
一些章节的开头罗列出了通用概念，这是为了更通透地讲解相关知识的来龙去脉。如果你对这部分内容不了解，那么建议你把这部分内容（属于前置知识）认真看完再去看后面的内容。如果你对这部分内容已经有了充分的了解，那么完全可以跳过，直接选择你最关心的内容去阅读。
章节概述
第1 章 新时代的语言。这一章将从Rust 语言的发展历史概述开始，引出Rust 的设计哲学，通过设计哲学进一步阐述Rust 的语言架构。该语言架构也是本书组织内容时遵循的准则之一。这一章还将介绍Rust 语言社区的现状和未来展望。最重要的是，这一章将介绍Rust代码的执行流程，这对于理解本书后面的章节会有所帮助。
第2 章 语言精要。学习任何一门语言时，首先要做的就是了解其语法。这一章将罗列Rust 语言中的常用语法，但不是简单罗列，而是遵循一定的逻辑进行罗列。在介绍语法之前，这一章会先对Rust 语言的基本构成做整体概述。然后将介绍一个非常重要的概念：表达式。它是Rust 语法遵循的最简单的准则之一。接下来才会依次介绍Rust 中最常用的语法，让读者对Rust 语言有一个初步的了解。
第3 章 类型系统。类型系统是现代编程语言的重要支柱。这一章首先将以通用概念的形式介绍类型系统相关的概念，目的是帮助不了解类型系统的读者建立初步认知。接下来将从三方面阐述Rust 的类型系统。为了理解Rust 基于栈来管理资源的思想，有必要先了解Rust中对类型的分类，比如可确定大小类型、动态大小类型和零大小类型等。这一章还将介绍Rust类型推导功能及其不足。接下来将介绍Rust 中的泛型编程。泛型是Rust 类型系统中最重要
的一个概念。最后会介绍Rust 的“灵魂”，trait 系统。对类型系统建立一定的认知，有利于学习后面的内容。
第4 章 内存管理。这一章首先将介绍底层内存管理的通用概念。在此基础上，围绕内存安全这个核心，从变量定义到智能指针，逐渐阐述Rust 中资源管理的哲学。这部分内容是真正理解Rust 所有权机制的基础。
第5 章 所有权系统。这一章首先会介绍关于值和引用语义的通用概念，然后在此基础上探讨Rust 的所有权机制。读者将看到，Rust 如何结合类型系统和底层内存管理机制，以及上层值和引用的语义形成现在的Rust 所有权系统。然后，进一步围绕内存安全的核心，阐述借用检查和生命周期参数的意义。通过这一章的学习，读者将会对Rust 的所有权系统有全面深入的了解。
第6 章 函数、闭包和迭代器。在对Rust 的类型系统和内存安全机制有了一定了解之后，我们将开始深入学习Rust 编程最常用的语法结构。函数是Rust 中最常用的语法单元。Rust的函数承载了诸多函数式编程范式的特性，比如高阶函数、参数模式匹配等，同时也承载了面向对象范式的特性，比如为结构体及其实例实现方法，实际上就是一个函数调用的语法糖。
然后将介绍闭包的用法和特性，帮助读者对闭包建立全面深入的认知，更重要的是，通过学习闭包的实现原理，进一步了解Rust 中零成本抽象的哲学思想。最后介绍迭代器模式，以及Rust 中的迭代器实现机制。迭代器也是Rust 最常用的特性，通过这一章的学习，你将彻底了解迭代器。
第7 章 结构化编程。这一章将对Rust 混合范式编程进行探讨，会重点介绍Rust 中的结构体和枚举体，以及它们如何在日常编程中以面向对象风格编程。同时，还将介绍三种设计模式，前两种是Rust 标准库以及第三方库常用的设计模式，最后是一种合理利用Rust 资源管理哲学的设计模式。通过学习这一章的内容，有利于掌握地道的Rust 编程风格。
第8 章 字符串与集合类型。字符串是每门编程语言最基本的数据类型，Rust 自然也不例外。出于内存安全的考虑，Rust 中的字符串被分为了多种，并且语言自身没有自带正则表达式引擎。这一章将从字符编码开始，围绕内存安全，对Rust 中的字符和字符串做彻底梳理，并且阐述如何在没有正则表达式引擎的情况下，满足字符串进行匹配搜索等的需求。集合类型也是编程中必不可少的数据结构。这一章将着重介绍动态数组Vector 和Key-Value 映射集HashMap 的使用，而且还会深入挖掘HashMap 底层的实现原理，介绍Rust 标准库提供的HashMap 安全性，进一步探讨如何用Rust 实现一个生产级的数据结构。最后将通过探讨一个Rust 安全漏洞的成因，来帮助读者正确理解容量的概念，从而写出更安全的代码。
第9 章 构建健壮的程序。对于如何构建健壮的系统，Rust 给出了非常工程化的解决方案。Rust 将系统中的异常分为了多个层次，分别给出了对应的处理手段。在这一章，读者将学习Rust 是如何以分层的错误处理解决方案来帮助开发者构建健壮系统的。
第10 章 模块化编程。现代编程语言的一大特色就是可以方便地进行模块化，这样有利于系统的设计、维护和协作。Rust 在模块化编程方面做得很好。这一章首先将介绍Rust 强大的包管理系统Cargo。然后会以真实的代码实例阐述Rust 的模块系统，并且将包含Rust 2018版本中模块系统的重大改进。最后将以一个完整的项目为例阐述如何使用Rust 开发自己的crate。
第11 章 安全并发。Rust 从两方面支持并发编程。首先，利用类型安全和内存安全的基础，解决了多线程并发安全中的痛点：数据竞争。Rust 可以在编译时发现多线程并发代码中的安全问题。其次，Rust 为了达成高性能服务器开发的目标，开始全面拥抱异步开发。这一章将从线程安全的通用概念开始，从Rust 多线程并发讲到异步并发支持，带领读者逐步形成全面、深入、通透的理解。
第12 章 元编程。元编程即程序生成程序的能力。Rust 为开发者提供了多种元编程能力。这一章将从反射开始介绍Rust 中的元编程。虽然Rust 的反射功能没有动态语言的那么强大，但是Rust 提供了强大的宏系统。这一章将从Rust 的编译过程出发，带领读者深入理解Rust的宏系统的工作机制，并且以具体的实例帮助读者理解编写宏的技巧。从声明宏到过程宏，再到编译器插件，以及第三方库syn 和quote 最新版的配合使用，都将在本章进行阐述。
第13 章 超越安全的边界。前面的章节内容基本都是建立在Safe Rust 的基础上的。而这一章将主要围绕Unsafe Rust 的内容来构建，主要分为4 大部分。首先将介绍Unsafe Rust 的基本语法和特性。然后，围绕基于Unsafe 进行安全抽象的核心，阐述Unsafe Rust 开发过程中可能引起未定义行为的地方，以及相应的解决方案。然后介绍FFI，通过具体的实例来阐述Rust 如何和其他语言交互，涉及C、C++、Ruby、Python、Node.js 等语言，还将介绍相关的第三方库。最后，将介绍未来互联网的核心技术WebAssembly，以及Rust 如何开发WebAssembly 和相关的工具链。
相信通过这13 章的内容，读者将会对Rust 有全面、深入和系统的认识。
勘误及更多资源
有人的地方就有Bug，此书当然也不例外。写书不仅是正确地传播知识和思想的途径，更是一种交流和沟通的方式。如果你发现本书中的任何错误、遗漏和解释不清楚的地方，欢迎提出反馈。
勘误说明：
? 直接提交issues。
? 标明具体的页码、行数和错误信息。
? 积极提出勘误者将获得合金Rust 勋章一枚。
更多的学习资源：
? 官方doc.rust-lang.org 列出了很多学习文档和资源。
? 订阅Rust 每日新闻1，了解Rust 社区生态发展，学习Rust。
致谢
首先，我要感谢Rust 社区中每一位帮助过我的朋友，没有你们的奉献，就没有这本书。
感谢Mike 组织社区编写的免费书籍Rust Primer。感谢Rust 社区中不知名的翻译者翻译官方的Rust Book。感谢知乎《Rust 编程》专栏作者辛苦的写作。感谢KiChjang、ELTON、CrLF0710、F001、Lingo、tennix、iovxw、wayslog、Xidorn、42、黑腹喵等其他社区里的朋友们，你们在我学习的过程中给予了我无私的帮助和解答，Rust 社区有你们真好。感谢知道我写作并一直鼓励和支持我的朋友们。衷心希望Rust 社区可以一直这么强大、温柔和友好。
然后，我要感谢电子工业出版社的刘恩惠编辑。感谢你给了我这个机会，让这本书从想法成为了现实。
最后，感谢我的妻子宋欣欣，因为她的温柔、大度、包容、信任和支持，才让我能够踏实且满含信心地做我自己想做的事。感谢我的父母，正是他们的培养，才使我具有积极、坚持不懈做事情的品格。

查看更多 > 图书评论

暂无评论

发表图书评论

评论标题：
评论内容：
验证码：: 看不清楚
点击刷新
: 您还没有登录，请登录后再评论。
点击“登录”

购买过本书的顾客还买过

{{data.bookName}}

￥{{data.price}}