|
关于我们
 书单推荐 新书推荐 |
Rust编程之道 
定 价：128 元
9 7 3 8 5 7 4 1 8 2 5 1 4 读者对象:适合本书的读者群体包括： 1. 有一定编程经验，想要学习Rust的初学者。 2. 对Rust有一定了解，还想对Rust深入学习的进阶者。 本书不适合完全没有编程基础的人学习。 
Rust 是一门利用现代化的类型系统，有机地融合了内存管理、所有权语义和混合编程范式的编程语言。它不仅能科学地保证程序的正确性，还能保证内存安全和线程安全。同时，还有能与C/C++语言媲美的性能，以及能和动态语言媲美的开发效率。本书并非对语法内容进行简单罗列讲解，而是从四个维度深入全面且通透地介绍了Rust 语言。从设计哲学出发，探索Rust 语言的内在一致性；从源码分析入手，探索Rust 地道的编程风格；从工程角度着手，探索Rust 对健壮性的支持；从底层原理开始，探索Rust 内存安全的本质。本书涵盖了Rust 2018 的特性，适合有一定编程经验且想要学习Rust 的初学者，以及对Rust 有一定的了解，想要继续深入学习的进阶者。
张汉东，80后，资深软件工程师、企业独立咨询师、技术作者译者。爱好读书、写作，喜欢研究技术、学习之道，以及心智和认知开发模式。曾在互联网行业沉浮十余载，先后效力于电商、社交游戏、广告和众筹领域。作为企业独立咨询师，先后为思科、平安科技和闪迪等公司提供咨询服务。目前在心智教育及创客领域开疆拓土。是《Ruby原理剖析》一书的译者。喜欢Rust语言，为Rust语言提交了三次编译器Bug，并协助修复其中之一。为官方Rust 2018 Guide做过贡献，并数次提出改进意见。参与了国内Rust社区的管理和运营，在2018年打造了《Rust每日新闻》频道，深受Rustacean们的喜爱。为初学者精心打造了Rust必学第一课：知乎Live《如何系统地学习Rust语言》，获得五星好评。
第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
你还可能感兴趣
我要评论
|
