《Rust 程序设计（第2版）》吉姆•布兰迪【文字版_PDF电子书_】
| 书名：Rust 程序设计（第2版） 作者：[美]吉姆·布兰迪（JimBlandy）/[美]贾森•奥伦多 出版社：人民邮电出版社 译者：汪志成（@雪狼） 出版日期：2023-9-5 页数：576 ISBN：9787115621818 | 9.2 豆瓣评分 | 点击喜欢 | 全网资源sm.nayona.cn |
内容简介：
本书是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等先进语言在一些关键领域构建健壮且适应性强的系统软件，特别是在医疗保健和数据所有权管理等领域。
目 录：
专家推荐
译者序
前言
中文版审读致谢
第1章 系统程序员也能享受美好 1
1.1 Rust为你负重前行 2
1.2 高效并行编程 3
1.3 性能毫不妥协 3
1.4 协作无边无界 4
第2章 Rust导览 5
2.1 rustup与Cargo 6
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 Box 52
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 String 61
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与match 115
6.5.1 if let 117
6.5.2 循环 117
6.6 循环中的控制流 119
6.7 return表达式 120
6.8 为什么Rust中会有loop 121
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 panic 128
7.1.1 展开调用栈 129
7.1.2 中止 130
7.2 Result 130
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 为什么是Result 140
第8章 crate与模块 141
8.1 crate 141
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.lock 167
8.8 将crate发布到crates.io 168
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形式传入self 179
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 特型中的Self 224
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 Trait 232
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与IndexMut 250
12.5 其他运算符 252
第13章 实用工具特型 253
13.1 Drop 254
13.2 Sized 256
13.3 Clone 259
13.4 Copy 260
13.5 Deref与DerefMut 260
13.6 Default 263
13.7 AsRef与AsMut 264
13.8 Borrow与BorrowMut 266
13.9 From与Into 267
13.10 TryFrom与TryInto 270
13.11 ToOwned 271
13.12 Borrow与ToOwned的实际运用：谦卑的Cow 271
第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 FnOnce 281
14.4.3 FnMut 282
14.4.4 对闭包的Copy与Clone 284
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与successors 295
15.2.4 drain方法 296
15.2.5 其他迭代器源 297
15.3 迭代器适配器 298
15.3.1 map与filter 298
15.3.2 filter_map与flat_map 300
15.3.3 flatten 302
15.3.4 take与take_while 304
15.3.5 skip与skip_while 305
15.3.6 peekable 305
15.3.7 fuse 306
15.3.8 可逆迭代器与rev 307
15.3.9 inspect 308
15.3.10 chain 309
15.3.11 enumerate 309
15.3.12 zip 310
15.3.13 by_ref 310
15.3.14 cloned与copied 311
15.3.15 cycle 312
15.4 消耗迭代器 313
15.4.1 简单累加：count、sum和product 313
15.4.2 min与max 313
15.4.3 max_by与min_by 314
15.4.4 max_by_key与min_by_key 314
15.4.5 对条目序列进行比较 315
15.4.6 any与all 315
15.4.7 position、rposition和ExactSizeIterator 316
15.4.8 fold与rfold 316
15.4.9 try_fold与try_rfold 317
15.4.10 nth与nth_back 318
15.4.11 last 319
15.4.12 find、rfind和find_map 319
15.4.13 构建集合：collect与FromIterator 320
15.4.14 Extend特型 322
15.4.15 partition 322
15.4.16 for_each与try_for_each 323
15.5 实现自己的迭代器 324
第16章 集合 328
16.1 概述 329
16.2 Vec 330
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 VecDeque 343
16.4 BinaryHeap 344
16.5 HashMap与BTreeMap 346
16.5.1 条目 349
16.5.2 对Map进行迭代 351
16.6 HashSet与BTreeSet 351
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和Unicode 359
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与str 364
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 crate 393
第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与Path 408
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 rayon 424
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与Sync 435
19.2.6 绝大多数迭代器能通过管道传给通道 437
19.2.7 除管道之外的用法 438
19.3 共享可变状态 439
19.3.1 什么是互斥锁 439
19.3.2 Mutex 440
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 Future 455
20.1.2 异步函数与await表达式 456
20.1.3 从同步代码调用异步函数：block_on 458
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_blocking 470
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_blocking 489
20.3.2 实现block_on 491
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 示例：RefWithFlag 535
22.8.3 可空指针 537
22.8.4 类型大小与对齐方式 537
22.8.5 指针运算 538
22.8.6 移动入和移动出内存 539
22.8.7 示例：GapBuffer 542
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
浏览器不支持脚本！
有需要联系v；hx-hx4
摘要：《Rust 程序设计（第2版）》是吉姆•布兰迪撰写的一部关于Rust编程语言的权威指南。这本书通过系统化的讲解，深入探讨了Rust语言的基本概念、语法特性及其在实际开发中的应用。作者不仅关注语言的基础知识，还通过示例代码、练习题和最佳实践，帮助读者更好地掌握Rust的独特之处。全书内容丰富，适合各个层次的程序员，尤其是希望提升代码安全性和性能的开发者。通过对Rust内存管理、并发编程和实用工具的深入分析，本书为读者提供了全面的学习路径，是理解和掌握Rust不可或缺的资源。
1、Rust语言的基本概念
Rust语言是由Mozilla开发的系统编程语言，以其内存安全和并发性著称。与其他编程语言相比，Rust具有独特的所有权系统，这一系统可以有效地避免常见的内存管理错误，例如空指针和数据竞争。吉姆•布兰迪在书中详细介绍了这一系统的工作原理，帮助读者理解如何在编写Rust程序时合理管理内存。
本书的前几章聚焦于Rust的基本语法和数据结构，包括变量、数据类型、控制流和函数定义。通过这些基础知识的学习，读者能够快速上手，编写简单的Rust程序。作者还提供了丰富的示例代码，确保读者在实践中理解每个概念。
此外，Rust的模块系统也是一个重要的主题。书中讲解了如何组织代码模块，以及如何使用Cargo工具管理项目依赖。通过模块化设计，Rust程序员能够提高代码的可读性和可维护性，促进团队合作和代码共享。
2、内存管理与安全性
内存管理是Rust语言的一大亮点。传统编程语言如C和C++通常依赖程序员手动管理内存，这容易导致内存泄漏和其他错误。而Rust通过其所有权模型，自动管理内存，确保每个值都有一个明确的所有者，且在不再使用时自动释放内存。吉姆•布兰迪详细说明了这一机制的工作原理，帮助读者掌握如何在Rust中安全地操作内存。
书中还介绍了“借用”这一概念，强调了如何在不拥有数据的情况下安全地访问它。这种方法极大地减少了潜在的并发错误，提高了程序的稳定性。通过深入的示例和解释，读者能够理解如何在实际应用中有效利用这一特性。
此外，Rust还提供了丰富的错误处理机制，使得程序在遇到错误时能够安全退出而不是崩溃。布兰迪对Rust的Result和Option类型进行了详尽的阐述，指导读者如何优雅地处理错误和异常情况，进一步提升了程序的健壮性。
3、并发编程的优势
并发编程在现代软件开发中愈发重要，Rust在这方面展现了显著的优势。吉姆•布兰迪在书中探讨了Rust如何通过其所有权系统确保线程安全，使得并发编程变得更加简单和安全。读者可以了解到Rust在设计时就考虑到了并发性，这样可以有效地避免数据竞争和死锁等问题。
书中介绍了Rust的线程模型以及如何创建和管理线程，涵盖了使用标准库的线程API和更高层次的并发抽象如消息传递和共享状态。通过实例，布兰迪让读者看到Rust在高性能并发编程中的应用场景，并提供了一些最佳实践建议。
此外，Rust的异步编程特性也是一个重要的讨论点。布兰迪详细解释了Future和Async/Await的使用方式，使得读者能够理解如何编写高效的异步代码，以充分利用系统资源，提高程序的响应能力。
4、实用工具与最佳实践
在《Rust 程序设计（第2版）》中，吉姆•布兰迪不仅讲解了Rust语言的基础和高级特性，还介绍了丰富的开发工具和最佳实践。例如，Cargo作为Rust的包管理工具，简化了项目的创建、依赖管理和构建过程。书中详细演示了如何使用Cargo进行项目管理，帮助读者快速上手。
作者还探讨了Rust生态系统中的其他重要工具，如Clippy和Rustfmt，它们分别用于代码审查和格式化。这些工具可以显著提高代码质量，促进团队开发中的一致性和可维护性。通过介绍这些工具的使用，读者能够更高效地进行Rust开发。
最后，布兰迪还分享了一些在Rust开发中的最佳实践，包括代码结构、错误处理和性能优化等。这些实践不仅能帮助新手快速成长，也为经验丰富的开发者提供了提升代码质量和效率的实用建议。
总结：
《Rust 程序设计（第2版）》是一本全面且深入的Rust学习资源，适合不同水平的开发者。通过系统的讲解和丰富的实例，读者能够从中获得扎实的Rust编程基础，并掌握其在内存管理、并发编程和工具使用等方面的优势。布兰迪的教学方式清晰易懂，使得即使是初学者也能逐步建立对Rust的信心。
总的来说，这本书不仅是Rust语言学习的良好起点，也为开发者提供了在实际项目中应用Rust的宝贵经验和技巧。无论是想提高代码安全性的程序员，还是希望提升开发效率的团队，都会从中受益匪浅。
本文由nayona.cn整理
联系我们
关注公众号
微信扫一扫 
支付宝扫一扫 
