Rust程序设计（第2版）

图书标准信息

• 作者 [美]吉姆·布兰迪(Jim Blandy)(美)贾森·奥伦多夫(Jason Or
• 出版社 人民邮电出版社
• 出版时间 2023-09
• 版次 1
• ISBN 9787115621818
• 定价 179.80元
• 装帧 平装
• 开本 其他
• 纸张 胶版纸
• 页数 576页
• 字数 896千字

【内容简介】

本书是Rust领域经典参考书，由业内资深系统程序员编写，广受读者好评。
  书中全面介绍了Rust这种新型系统编程语言——具有非常好的安全性，兼具C和C++的高性能，并大大简化了并发程序的编写。第2版对上一版内容进行了重组和完善，新增了对“异步编程”的介绍。借助书中的大量案例，你也能用Rust编写出兼顾安全性与高性能的程序。本书内容包括基本数据类型、所有权、引用、表达式、错误处理、crate与模块、结构、枚举与模式等基础知识，以及特型与泛型、闭包、迭代器、集合、字符串与文本、输入与输出、并发、异步编程、宏等进阶知识。
  本书适合所有学习Rust的开发者，尤其适合系统程序员，从C++转向Rust的程序员，以及具有C、C#、Jave、Python、JavaScript等其他编程语言基础并希望学习Rust的程序员。

【作者简介】

[美]吉姆·布兰迪（Jim Blandy），Mozilla Firefox工程师，Subversion版本控制系统初代设计者之一。拥有40多年编程经验，其中包括30多年自由软件开发经验，曾在GNU Emacs、GNU Debugger等项目上工作。

[美]贾森·奥伦多夫（Jason Orendorff），GitHub工程师，专注开发尚未公开的Rust项目，曾在Mozilla参与JavaScript引擎SpiderMonkey的开发。兴趣广泛，包括：语法学、烘焙、时间旅行，以及帮助人们理解复杂主题。

[美]莉奥诺拉·F. S. 廷德尔（Leonora F. S. Tindall），软件工程师、类型系统爱好者。她喜欢使用Rust等先进语言在一些关键领域构建健壮且适应性强的系统软件，特别是在医疗保健和数据所有权管理等领域。

【译者简介】

汪志成（@雪狼），Thoughtworks专家级咨询师、Google Developer Expert、25年码农。终身学习者，兴趣多元，涉猎广泛，目前专注研究Rust。

【目录】

目录

专家推荐

译者序

前言

中文版审读致谢

第 1章　系统程序员也能享受美好1

1.1　Rust为你负重前行2

1.2　高效并行编程3

1.3　性能毫不妥协3

1.4　协作无边无界4

第 2章　Rust导览5

2.1　rustup与Cargo6

2.2　Rust函数8

2.3　编写与运行单元测试9

2.4　处理命令行参数10

2.5　搭建Web服务器13

2.6　并发18

2.6.1　什么是曼德博集19

2.6.2　解析并配对命令行参数22

2.6.3　从像素到复数的映射24

2.6.4　绘制曼德博集25

2.6.5　写入图像文件26

2.6.6　并发版曼德博程序27

2.6.7　运行曼德博绘图器32

2.6.8　大“安”无形33

2.7　文件系统与命令行工具33

2.7.1　命令行界面34

2.7.2　读写文件36

2.7.3　查找并替换37

第3章　基本数据类型39

3.1　固定宽度的数值类型41

3.1.1　整型42

3.1.2　检查算法、回绕算法、饱和算法和溢出算法45

3.1.3　浮点类型46

3.2　布尔类型48

3.3　字符49

3.4　元组50

3.5　指针类型51

3.5.1　引用52

3.5.2　Box52

3.5.3　裸指针53

3.6　数组、向量和切片53

3.6.1　数组53

3.6.2　向量54

3.6.3　切片57

3.7　字符串类型58

3.7.1　字符串字面量58

3.7.2　字节串59

3.7.3　内存中的字符串60

3.7.4　String61

3.7.5　使用字符串62

3.7.6　其他类似字符串的类型62

3.8　类型别名63

3.9　前路展望63

第4章　所有权与移动64

4.1　所有权65

4.2　移动70

4.2.1　更多移动类操作74

4.2.2　移动与控制流75

4.2.3　移动与索引内容75

4.3　Copy类型：关于移动的例外情况77

4.4　Rc与Arc：共享所有权80

第5章　引用83

5.1　对值的引用84

5.2　使用引用86

5.2.1　Rust引用与C++引用87

5.2.2　对引用变量赋值88

5.2.3　对引用进行引用88

5.2.4　比较引用89

5.2.5　引用永不为空89

5.2.6　借用任意表达式结果值的引用89

5.2.7　对切片和特型对象的引用90

5.3　引用安全90

5.3.1　借用局部变量91

5.3.2　将引用作为函数参数93

5.3.3　把引用传给函数95

5.3.4　返回引用95

5.3.5　包含引用的结构体96

5.3.6　不同的生命周期参数98

5.3.7　省略生命周期参数100

5.4　共享与可变101

5.5　应对复杂对象关系107

第6章　表达式109

6.1　表达式语言109

6.2　优先级与结合性110

6.3　块与分号112

6.4　声明113

6.5　if与match115

6.5.1　if let117

6.5.2　循环117

6.6　循环中的控制流119

6.7　return表达式120

6.8　为什么Rust中会有loop121

6.9　函数与方法调用122

6.10　字段与元素123

6.11　引用运算符124

6.12　算术运算符、按位运算符、比较运算符和逻辑运算符125

6.13　赋值125

6.14　类型转换126

6.15　闭包127

6.16　前路展望127

第7章　错误处理128

7.1　panic128

7.1.1　展开调用栈129

7.1.2　中止130

7.2　Result130

7.2.1　捕获错误131

7.2.2　Result类型别名132

7.2.3　打印错误132

7.2.4　传播错误134

7.2.5　处理多种Error类型135

7.2.6　处理“不可能发生”的错误136

7.2.7　忽略错误138

7.2.8　处理main()中的错误138

7.2.9　声明自定义错误类型139

7.2.10　为什么是Result140

第8章　crate与模块141

8.1　crate141

8.1.1　版本144

8.1.2　创建配置文件145

8.2　模块145

8.2.1　嵌套模块146

8.2.2　单独文件中的模块147

8.2.3　路径与导入149

8.2.4　标准库预导入152

8.2.5　公开use声明152

8.2.6　公开结构体字段152

8.2.7　静态变量与常量153

8.3　将程序变成库153

8.4　src/bin目录155

8.5　属性156

8.6　测试与文档158

8.6.1　集成测试161

8.6.2　文档161

8.6.3　文档测试163

8.7　指定依赖项166

8.7.1　版本166

8.7.2　Cargo.lock167

8.8　将crate发布到crates.io168

8.9　工作空间170

8.10　更多好资源170

第9章　结构体172

9.1　具名字段型结构体172

9.2　元组型结构体175

9.3　单元型结构体175

9.4　结构体布局176

9.5　用impl定义方法177

9.5.1　以Box、Rc或Arc形式传入self179

9.5.2　类型关联函数179

9.6　关联常量180

9.7　泛型结构体181

9.8　带生命周期参数的泛型结构体183

9.9　带常量参数的泛型结构体183

9.10　让结构体类型派生自某些公共特型185

9.11　内部可变性186

第 10章　枚举与模式190

10.1　枚举191

10.1.1　带数据的枚举193

10.1.2　内存中的枚举194

10.1.3　用枚举表示富数据结构194

10.1.4　泛型枚举196

10.2　模式198

10.2.1　模式中的字面量、变量和通配符201

10.2.2　元组型模式与结构体型模式202

10.2.3　数组型模式与切片型模式203

10.2.4　引用型模式204

10.2.5　匹配守卫206

10.2.6　匹配多种可能性206

10.2.7　使用@模式绑定207

10.2.8　模式能用在哪里207

10.2.9　填充二叉树209

10.3　大局观210

第 11章　特型与泛型211

11.1　使用特型213

11.1.1　特型对象214

11.1.2　泛型函数与类型参数215

11.1.3　使用哪一个219

11.2　定义与实现特型220

11.2.1　默认方法221

11.2.2　特型与其他人的类型222

11.2.3　特型中的Self224

11.2.4　子特型225

11.2.5　类型关联函数226

11.3　完全限定的方法调用227

11.4　定义类型之间关系的特型228

11.4.1　关联类型（或迭代器的工作原理）229

11.4.2　泛型特型（或运算符重载的工作原理）231

11.4.3　impl Trait232

11.4.4　关联常量234

11.5　逆向工程求限界235

11.6　以特型为基础238

第 12章　运算符重载239

12.1　算术运算符与按位运算符240

12.1.1　一元运算符242

12.1.2　二元运算符243

12.1.3　复合赋值运算符244

12.2　相等性比较245

12.3　有序比较247

12.4　Index与IndexMut250

12.5　其他运算符252

第 13章　实用工具特型253

13.1　Drop254

13.2　Sized256

13.3　Clone259

13.4　Copy260

13.5　Deref与DerefMut260

13.6　Default263

13.7　AsRef与AsMut264

13.8　Borrow与BorrowMut266

13.9　From与Into267

13.10　TryFrom与TryInto270

13.11　ToOwned271

13.12　Borrow与ToOwned的实际运用：谦卑的Cow271

第 14章　闭包273

14.1　捕获变量274

14.1.1　借用值的闭包275

14.1.2　“窃取”值的闭包275

14.2　函数与闭包的类型277

14.3　闭包性能279

14.4　闭包与安全280

14.4.1　“杀死”闭包280

14.4.2　FnOnce281

14.4.3　FnMut282

14.4.4　对闭包的Copy与Clone284

14.5　回调285

14.6　高效地使用闭包288

第 15章　迭代器290

15.1　Iterator特型与IntoIterator特型291

15.2　创建迭代器292

15.2.1　iter方法与iter_mut方法293

15.2.2　IntoIterator的实现293

15.2.3　from_fn与successors295

15.2.4　drain方法296

15.2.5　其他迭代器源297

15.3　迭代器适配器298

15.3.1　map与filter298

15.3.2　filter_map与flat_map300

15.3.3　flatten302

15.3.4　take与take_while304

15.3.5　skip与skip_while305

15.3.6　peekable305

15.3.7　fuse306

15.3.8　可逆迭代器与rev307

15.3.9　inspect308

15.3.10　chain309

15.3.11　enumerate309

15.3.12　zip310

15.3.13　by_ref310

15.3.14　cloned与copied311

15.3.15　cycle312

15.4　消耗迭代器313

15.4.1　简单累加：count、sum和product313

15.4.2　min与max313

15.4.3　max_by与min_by314

15.4.4　max_by_key与min_by_key314

15.4.5　对条目序列进行比较315

15.4.6　any与all315

15.4.7　position、rposition和ExactSizeIterator316

15.4.8　fold与rfold316

15.4.9　try_fold与try_rfold317

15.4.10　nth与nth_back318

15.4.11　last319

15.4.12　find、rfind和find_map319

15.4.13　构建集合：collect与FromIterator320

15.4.14　Extend特型322

15.4.15　partition322

15.4.16　for_each与try_for_each323

15.5　实现自己的迭代器324

第 16章　集合328

16.1　概述329

16.2　Vec330

16.2.1　访问元素331

16.2.2　迭代332

16.2.3　扩大向量与收缩向量332

16.2.4　联结336

16.2.5　拆分336

16.2.6　交换339

16.2.7　填充339

16.2.8　排序与搜索339

16.2.9　比较切片341

16.2.10　随机元素341

16.2.11　Rust中不存在失效型错误342

16.3　VecDeque343

16.4　BinaryHeap344

16.5　HashMap与BTreeMap346

16.5.1　条目349

16.5.2　对Map进行迭代351

16.6　HashSet与BTreeSet351

16.6.1　对Set进行迭代352

16.6.2　当相等的值不完全相同时353

16.6.3　针对整个Set的运算353

16.7　哈希354

16.8　使用自定义哈希算法355

16.9　在标准集合之外357

第 17章　字符串与文本358

17.1　一些Unicode背景知识358

17.1.1　ASCII、Latin-1和Unicode359

17.1.2　UTF-8编码359

17.1.3　文本方向性361

17.2　字符（char）361

17.2.1　字符分类361

17.2.2　处理数字362

17.2.3　字符大小写转换363

17.2.4　与整数之间的转换364

17.3　String与str364

17.3.1　创建字符串值365

17.3.2　简单探查366

17.3.3　追加文本与插入文本366

17.3.4　移除文本与替换文本368

17.3.5　搜索与迭代的约定368

17.3.6　搜索文本的模式369

17.3.7　搜索与替换370

17.3.8　遍历文本371

17.3.9　修剪373

17.3.10　字符串的大小写转换374

17.3.11　从字符串中解析出其他类型374

17.3.12　将其他类型转换为字符串374

17.3.13　借用其他类似文本的类型375

17.3.14　以UTF-8格式访问文本376

17.3.15　从UTF-8数据生成文本376

17.3.16　推迟分配377

17.3.17　把字符串当作泛型集合379

17.4　格式化各种值379

17.4.1　格式化文本值380

17.4.2　格式化数值381

17.4.3　格式化其他类型383

17.4.4　格式化值以进行调试383

17.4.5　格式化指针以进行调试384

17.4.6　按索引或名称引用参数385

17.4.7　动态宽度与动态精度386

17.4.8　格式化自己的类型386

17.4.9　在自己的代码中使用格式化语言388

17.5　正则表达式389

17.5.1　Regex的基本用法389

17.5.2　惰性构建正则表达式值390

17.6　规范化391

17.6.1　规范化形式392

17.6.2　unicode-normalization crate393

第 18章　输入与输出395

18.1　读取器与写入器396

18.1.1　读取器397

18.1.2　缓冲读取器398

18.1.3　读取行399

18.1.4　收集行401

18.1.5　写入器402

18.1.6　文件403

18.1.7　寻址404

18.1.8　其他读取器与写入器类型404

18.1.9　二进制数据、压缩和序列化406

18.2　文件与目录407

18.2.1　OsStr与Path408

18.2.2　Path与PathBuf的方法409

18.2.3　访问文件系统的函数411

18.2.4　读取目录412

18.2.5　特定于平台的特性413

18.3　网络414

第 19章　并发417

19.1　分叉与合并并行418

19.1.1　启动与联结420

19.1.2　跨线程错误处理422

19.1.3　跨线程共享不可变数据422

19.1.4　rayon424

19.1.5　重温曼德博集426

19.2　通道427

19.2.1　发送值429

19.2.2　接收值431

19.2.3　运行管道432

19.2.4　通道的特性与性能434

19.2.5　线程安全：Send与Sync435

19.2.6　绝大多数迭代器能通过管道传给通道437

19.2.7　除管道之外的用法438

19.3　共享可变状态439

19.3.1　什么是互斥锁439

19.3.2　Mutex440

19.3.3　mut与互斥锁442

19.3.4　为什么互斥锁不是“银弹”443

19.3.5　死锁443

19.3.6　“中毒”的互斥锁444

19.3.7　使用互斥锁的多消费者通道444

19.3.8　读/写锁（RwLock）445

19.3.9　条件变量（Condvar）446

19.3.10　原子化类型447

19.3.11　全局变量448

19.4　在Rust中编写并发代码的一点儿经验451

第 20章　异步编程452

20.1　从同步到异步453

20.1.1　Future455

20.1.2　异步函数与await表达式456

20.1.3　从同步代码调用异步函数：block_on458

20.1.4　启动异步任务460

20.1.5　异步块464

20.1.6　从异步块构建异步函数466

20.1.7　在线程池中启动异步任务467

20.1.8　你的Future实现Send了吗467

20.1.9　长时间运行的计算：yield_now与spawn_blocking470

20.1.10　对几种异步设计进行比较471

20.1.11　一个真正的异步HTTP客户端471

20.2　异步客户端与服务器472

20.2.1　Error类型与Result类型474

20.2.2　协议474

20.2.3　获取用户输入：异步流475

20.2.4　发送数据包477

20.2.5　接收数据包：更多异步流478

20.2.6　客户端的main函数480

20.2.7　服务器的main函数481

20.2.8　处理聊天连接：异步互斥锁482

20.2.9　群组表：同步互斥锁484

20.2.10　聊天组：tokio的广播通道485

20.3　原始Future与执行器：Future什么时候值得再次轮询488

20.3.1　调用唤醒器：spawn_blocking489

20.3.2　实现block_on491

20.4　固定（Pin）493

20.4.1　Future生命周期的两个阶段493

20.4.2　固定指针496

20.4.3　Unpin特型497

20.5　什么时候要用异步代码498

第 21章　宏500

21.1　宏基础501

21.1.1　宏展开的基础502

21.1.2　意外后果503

21.1.3　重复505

21.2　内置宏507

21.3　调试宏508

21.4　构建json!宏509

21.4.1　片段类型510

21.4.2　宏中的递归513

21.4.3　将特型与宏一起使用514

21.4.4　作用域界定与卫生宏516

21.4.5　导入宏和导出宏518

21.5　在匹配过程中避免语法错误519

21.6　超越macro_rules!520

第 22章　不安全代码522

22.1　不安全因素来自哪里523

22.2　不安全块524

22.3　示例：高效的ASCII字符串类型525

22.4　不安全函数527

22.5　不安全块还是不安全函数528

22.6　未定义行为529

22.7　不安全特型531

22.8　裸指针532

22.8.1　安全地解引用裸指针534

22.8.2　示例：RefWithFlag535

22.8.3　可空指针537

22.8.4　类型大小与对齐方式537

22.8.5　指针运算538

22.8.6　移动入和移动出内存539

22.8.7　示例：GapBuffer542

22.8.8　不安全代码中的panic安全性548

22.9　用联合体重新解释内存549

22.10　匹配联合体551

22.11　借用联合体551

第 23章　外部函数552

23.1　寻找共同的数据表示552

23.2　声明外部函数与变量556

23.3　使用库中的函数557

23.4　libgit2的裸接口560

23.5　libgit2的安全接口566

23.6　结论575

作者介绍576

封面介绍576