Rust 程序设计

Rust 程序设计

by Jim Blandy, Jason Orendorff
Released September 2020
Publisher(s): Posts & Telecom Press
ISBN: 9787115546494

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Book description

Rust是一门新的系统编程语言，兼具C和C++的高性能和底层控制能力，而且能保证内存安全和线程安全，是系统编程发展史上的一个巨大进步。本书对Rust进行了全面介绍，详细解释了这门语言的重要概念，并提供了大量清晰易懂的示例，逐步指导读者用Rust编写出既安全又高性能的程序。

本书由两位具有数十年经验的系统程序员撰写，他们不仅分享了自己对Rust的深刻见解，而且还提供了一些建议和操作实践，对Rust开发者和系统程序员十分有帮助。

  • Rust如何在内存中表示值（辅以图表）
  • 完整解释了所有权、转移、借用和生命期
  • Cargo、rustdoc、单元测试，以及如何在Rust公共包仓库上发布代码
  • 泛型代码、闭包、集合和迭代器等高级特性
  • Rust中的并发：线程、互斥量、通道和原子操作
  • 不安全代码，以及如何保持使用常规代码的完整性
  • 用丰富的例子展示了Rust各方面特性的综合运用

Table of contents

  1. 封面
  2. 扉页
  3. 版权
  4. 版权声明
  5. O’Reilly Media, Inc.介绍
  6. 目录 (1/2)
  7. 目录 (2/2)
  8. 前言
    1. 写作初衷
    2. 排版约定
    3. 本书内容
    4. 读者对象
    5. 使用代码示例
    6. O’Reilly在线学习平台（O’Reilly Online Learning）
    7. 联系我们
    8. 致谢
    9. 电子书
  9. 第1章 为什么是Rust
  10. 第2章 Rust初体验
    1. 2.1 下载和安装Rust
    2. 2.2 一个简单的函数
    3. 2.3 编写和运行单元测试
    4. 2.4 处理命令行参数
    5. 2.5 一个简单的Web服务器 (1/2)
    6. 2.5 一个简单的Web服务器 (2/2)
    7. 2.6 并发
      1. 2.6.1 到底什么是曼德布洛特集合
      2. 2.6.2 解析成对的命令行参数
      3. 2.6.3 像素到复数的映射
      4. 2.6.4 绘制集合
      5. 2.6.5 写出图像文件
      6. 2.6.6 并发的曼德布洛特程序
      7. 2.6.7 运行曼德布洛特绘图器
      8. 2.6.8 安全无形
  11. 第3章 基本类型
    1. 3.1 机器类型
      1. 3.1.1 整数类型
      2. 3.1.2 浮点类型
      3. 3.1.3 布尔类型
      4. 3.1.4 字符类型
    2. 3.2 元组
    3. 3.3 指针类型
      1. 3.3.1 引用
      2. 3.3.2 Box
      3. 3.3.3 原始指针
    4. 3.4 数组、向量和切片
      1. 3.4.1 数组
      2. 3.4.2 向量
      3. 3.4.3 逐个元素地构建向量
      4. 3.4.4 切片
    5. 3.5 字符串类型
      1. 3.5.1 字符串字面量
      2. 3.5.2 字节字符串
      3. 3.5.3 字符串在内存中的表示
      4. 3.5.4 字符串
      5. 3.5.5 使用字符串
      6. 3.5.6 其他类似字符串的类型
    6. 3.6 更多类型
  12. 第4章 所有权
    1. 4.1 所有权
    2. 4.2 转移
      1. 4.2.1 更多转移操作
      2. 4.2.2 转移与控制流
      3. 4.2.3 转移与索引内容
    3. 4.3 Copy类型：转移的例外
    4. 4.4 Rc和Arc：共享所有权
  13. 第5章 引用
    1. 5.1 引用作为值
      1. 5.1.1 Rust引用与C++引用
      2. 5.1.2 给引用赋值
      3. 5.1.3 引用的引用
      4. 5.1.4 比较引用
      5. 5.1.5 引用永远不为空
      6. 5.1.6 借用对任意表达式的引用
      7. 5.1.7 对切片和特型对象的引用
    2. 5.2 引用安全
      1. 5.2.1 借用局部变量
      2. 5.2.2 接收引用作为参数
      3. 5.2.3 将引用作为参数传递
      4. 5.2.4 返回引用
      5. 5.2.5 结构体包含引用
      6. 5.2.6 不同的生命期参数
      7. 5.2.7 省略生命期参数
    3. 5.3 共享与修改 (1/2)
    4. 5.3 共享与修改 (2/2)
    5. 5.4 征服对象之海
  14. 第6章 表达式
    1. 6.1 表达式语言
    2. 6.2 块与分号
    3. 6.3 声明
    4. 6.4 if与match
    5. 6.5 循环
    6. 6.6 return表达式
    7. 6.7 为什么Rust有循环
    8. 6.8 函数与方法调用
    9. 6.9 字段与元素
    10. 6.10 引用操作符
    11. 6.11 算术、位、比较和逻辑操作符
    12. 6.12 赋值
    13. 6.13 类型转换
    14. 6.14 闭包
    15. 6.15 优先级与关联性
    16. 6.16 展望
  15. 第7章 错误处理
    1. 7.1 诧异
      1. 7.1.1 展开栈
      2. 7.1.2 中止进程
    2. 7.2 结果
      1. 7.2.1 捕获错误
      2. 7.2.2 结果类型别名
      3. 7.2.3 打印错误
      4. 7.2.4 传播错误
      5. 7.2.5 处理多种错误类型
      6. 7.2.6 处理“不会发生”的错误
      7. 7.2.7 忽略错误
      8. 7.2.8 在main()中处理错误
      9. 7.2.9 声明自定义错误类型
      10. 7.2.10 为什么是结果
  16. 第8章 包和模块
    1. 8.1 包
    2. 8.2 模块
      1. 8.2.1 把模块写在单独的文件中
      2. 8.2.2 路径和导入
      3. 8.2.3 标准前置模块
      4. 8.2.4 特性项，Rust的基础
    3. 8.3 将程序作为库发布
    4. 8.4 src/bin目录
    5. 8.5 属性
    6. 8.6 测试和文档
      1. 8.6.1 集成测试
      2. 8.6.2 文档
      3. 8.6.3 文档测试
    7. 8.7 指定依赖
      1. 8.7.1 版本
      2. 8.7.2 Cargo.lock
    8. 8.8 把包发布到crates.io
    9. 8.10 还有惊喜
    10. 8.9 工作空间
  17. 第9章 结构体
    1. 9.1 命名字段结构体
    2. 9.2 类元组结构体
    3. 9.3 类基元结构体
    4. 9.4 结构体布局
    5. 9.5 通过impl定义方法
    6. 9.6 泛型结构体
    7. 9.7 带生命期参数的结构体
    8. 9.8 为结构体类型派生共有特型
    9. 9.9 内部修改能力
  18. 第10章 枚举与模式
    1. 10.1 枚举
      1. 10.1.1 包含数据的枚举
      2. 10.1.2 枚举的内存布局
      3. 10.1.3 使用枚举的富数据结构
      4. 10.1.4 泛型枚举
    2. 10.2 模式
      1. 10.2.1 模式中的字面量、变量和通配符
      2. 10.2.2 元组与结构体模式
      3. 10.2.3 引用模式
      4. 10.2.4 匹配多种可能性
      5. 10.2.5 模式护具
      6. 10.2.6 @模式
      7. 10.2.7 在哪里使用模式
      8. 10.2.8 填充二叉树
    3. 10.3 设计的考量
  19. 第11章 特型与泛型
    1. 11.1 使用特型
      1. 11.1.1 特型目标
      2. 11.1.2 特型目标布局
      3. 11.1.3 泛型函数
      4. 11.1.4 使用哪一个
    2. 11.2 定义和实现特型
      1. 11.2.1 默认方法
      2. 11.2.2 特型与其他人的类型
      3. 11.2.3 特型中的Self
      4. 11.2.4 子特型
      5. 11.2.5 静态方法
    3. 11.3 完全限定方法调用
    4. 11.4 定义类型关系的特型
      1. 11.4.1 关联类型（或迭代器工作原理）
      2. 11.4.2 泛型特型（或操作符重载的原理）
      3. 11.4.3 伴型特型（或rand::random()工作原理）
    5. 11.5 逆向工程绑定
    6. 11.6 小结
  20. 第12章 操作符重载
    1. 12.1 算术与位操作符
      1. 12.1.1 一元操作符
      2. 12.1.2 二元操作符
      3. 12.1.3 复合赋值操作符
    2. 12.2 相等测试
    3. 12.3 顺序比较
    4. 12.4 Index与IndexMut
    5. 12.5 其他操作符
  21. 第13章 实用特型
    1. 13.1 Drop
    2. 13.2 Sized
    3. 13.3 Clone
    4. 13.4 Copy
    5. 13.5 Deref与DerefMut
    6. 13.6 Default
    7. 13.7 AsRef与AsMut
    8. 13.8 Borrow与BorrowMut
    9. 13.9 From与Into
    10. 13.10 ToOwned
    11. 13.11 Borrow与ToOwned实例：谦逊的奶牛（Cow）
  22. 第14章 闭包
    1. 14.1 捕获变量
      1. 14.1.1 借用值的闭包
      2. 14.1.2 盗用值的闭包
    2. 14.2 函数与闭包类型
    3. 14.3 闭包的性能
    4. 14.4 闭包和安全
      1. 14.4.1 杀值的闭包
      2. 14.4.2 FnOnce
      3. 14.4.3 FnMut
    5. 14.5 回调
    6. 14.6 有效使用闭包
  23. 第15章 迭代器
    1. 15.1 Iterator和IntoIterator特型
    2. 15.2 创建迭代器
      1. 15.2.1 iter和iter_mut方法
      2. 15.2.2 IntoIterator实现
      3. 15.2.3 drain方法
      4. 15.2.4 其他迭代器源
    3. 15.3 迭代器适配器
      1. 15.3.1 map和filter
      2. 15.3.2 filter_map和flat_map
      3. 15.3.3 scan
      4. 15.3.4 take和take_while
      5. 15.3.5 skip和skip_while
      6. 15.3.6 peekable
      7. 15.3.7 fuse
      8. 15.3.8 可逆迭代器与rev
      9. 15.3.10 chain
      10. 15.3.9 inspect
      11. 15.3.11 enumerate
      12. 15.3.12 zip
      13. 15.3.13 by_ref
      14. 15.3.14 cloned
      15. 15.3.15 cycle
    4. 15.4 消费迭代器
      1. 15.4.1 简单累计：count、sum和product
      2. 15.4.2 max和min
      3. 15.4.3 max_by和min_by
      4. 15.4.4 max_by_key和min_by_key
      5. 15.4.5 比较项序列
      6. 15.4.6 any和all
      7. 15.4.7 position、rposition和ExactSizeIterator
      8. 15.4.8 fold
      9. 15.4.10 last
      10. 15.4.9 nth
      11. 15.4.11 find
      12. 15.4.12 构建集合：collect和FromIterator
      13. 15.4.13 Extend特型
      14. 15.4.14 partition
    5. 15.5 实现自己的迭代器
  24. 第16章 集合
    1. 16.1 概述
    2. 16.2 Vec
      1. 16.2.1 访问元素
      2. 16.2.2 迭代
      3. 16.2.3 增长和收缩向量
      4. 16.2.4 连接
      5. 16.2.5 拆分
      6. 16.2.6 交换
      7. 16.2.7 排序和搜索
      8. 16.2.8 比较切片
      9. 16.2.10 Rust排除无效错误
      10. 16.2.9 随机元素
    3. 16.3 VecDeque
    4. 16.4 LinkedList
    5. 16.5 BinaryHeap
    6. 16.6 HashMap和BTreeMap
      1. 16.6.1 条目
      2. 16.6.2 映射迭代
    7. 16.7 HashSet和BTreeSet
      1. 16.7.1 集迭代
      2. 16.7.2 相等的值不相同
      3. 16.7.3 整集操作
    8. 16.8 散列
    9. 16.9 标准集合之外
  25. 第17章 字符串与文本
    1. 17.1 Unicode背景知识
      1. 17.1.1 ASCII、Latin-1和Unicode
      2. 17.1.2 UTF-8
      3. 17.1.3 文本方向性
    2. 17.2 字符（char）
      1. 17.2.1 字符分类
      2. 17.2.2 处理数字
      3. 17.2.3 字符大小写转换
      4. 17.2.4 与整数相互转换
    3. 17.3 String与str
      1. 17.3.1 创建字符串值
      2. 17.3.2 简单检查
      3. 17.3.3 追加和插入文本
      4. 17.3.4 删除文本
      5. 17.3.5 搜索与迭代的约定
      6. 17.3.6 搜索文本的模式
      7. 17.3.7 搜索与替换
      8. 17.3.8 迭代文本
      9. 17.3.10 字符串大小写转换
      10. 17.3.11 从字符串解析出其他类型
      11. 17.3.9 修剪
      12. 17.3.12 将其他类型转换为字符串
      13. 17.3.13 作为其他类文本类型借用
      14. 17.3.14 访问UTF-8格式的文本
      15. 17.3.15 从UTF-8数据产生文本
      16. 17.3.16 阻止分配
      17. 17.3.17 字符串作为泛型集合
    4. 17.4 格式化值
      1. 17.4.1 格式化文本值
      2. 17.4.2 格式化数值
      3. 17.4.3 格式化其他类型
      4. 17.4.4 为调试格式化值
      5. 17.4.5 为调试格式化指针
      6. 17.4.6 通过索引或名字引用参数
      7. 17.4.7 动态宽度与精度
      8. 17.4.8 格式化自定义类型
      9. 17.4.9 在你的代码中使用格式化语言
    5. 17.5 正则表达式
      1. 17.5.1 基本用法
      2. 17.5.2 懒构建Regex值
    6. 17.6 规范化
      1. 17.6.1 规范化形式
      2. 17.6.2 unicode-normalization包
  26. 第18章 输入和输出
    1. 18.1 读取器和写入器
      1. 18.1.1 读取器
      2. 18.1.2 缓冲读取器
      3. 18.1.3 读取文本行
      4. 18.1.4 收集行
      5. 18.1.5 写入器
      6. 18.1.6 文件
      7. 18.1.7 搜寻
      8. 18.1.8 其他读取器和写入器类型
      9. 18.1.9 二进制数据、压缩与序列化
    2. 18.2 文件与目录
      1. 18.2.1 OsStr和Path
      2. 18.2.2 Path和PathBuf的方法
      3. 18.2.3 文件系统访问函数
      4. 18.2.4 读取目录
      5. 18.2.5 平台特定的特性
    3. 18.3 网络编程
  27. 第19章 并发
    1. 19.1 并行分叉–合并
      1. 19.1.1 产生及合并
      2. 19.1.2 跨线程错误处理
      3. 19.1.3 跨线程共享不可修改数据
      4. 19.1.4 Rayon
      5. 19.1.5 重温曼德布洛特集合
    2. 19.2 通道
      1. 19.2.1 发送值
      2. 19.2.2 接收值
      3. 19.2.3 运行管道
      4. 19.2.4 通道特性与性能
      5. 19.2.5 线程安全：Send与Sync
      6. 19.2.6 将所有迭代器都接到通道上
      7. 19.2.7 超越管道
    3. 19.3 共享可修改状态
      1. 19.3.1 什么是互斥量
      2. 19.3.2 Mutex
      3. 19.3.3 mut与Mutex
      4. 19.3.4 互斥量的问题
      5. 19.3.5 死锁
      6. 19.3.6 中毒的互斥量
      7. 19.3.7 使用互斥量的多生产者通道
      8. 19.3.8 读/写锁（RwLock）
      9. 19.3.9 条件变量（Condvar）
      10. 19.3.10 原子类型
      11. 19.3.11 全局变量
    4. 19.4 习惯编写Rust并发代码
  28. 第20章 宏
    1. 20.1 宏基础
      1. 20.1.1 宏扩展基础
      2. 20.1.2 意外结果
      3. 20.1.3 重复
    2. 20.2 内置宏
    3. 20.3 调试宏
    4. 20.4 json!宏
      1. 20.4.1 片段类型
      2. 20.4.2 在宏里使用递归
      3. 20.4.3 在宏里使用特型
      4. 20.4.4 作用域与自净宏
      5. 20.4.5 导入和导出宏
    5. 20.5 匹配时避免语法错误
    6. 20.6 超越macro_rules!
  29. 第21章 不安全代码
    1. 21.1 不安全源自哪里
    2. 21.2 不安全的块
    3. 21.3 不安全的函数
    4. 21.4 不安全的块还是不安全的函数
    5. 21.5 未定义行为
    6. 21.6 不安全的特型
    7. 21.7 原始指针
      1. 21.7.1 安全解引用原始指针
      2. 21.7.2 示例：RefWithFlag
      3. 21.7.3 可空指针
      4. 21.7.4 类型大小与对齐
      5. 21.7.5 指针算术
      6. 21.7.6 移入和移出内存
      7. 21.7.7 示例：GapBuffer (1/2)
      8. 21.7.7 示例：GapBuffer (2/2)
      9. 21.7.8 不安全代码中的诧异安全性
    8. 21.8 外来函数：在Rust中调用C和C++
      1. 21.8.1 查找共有数据表示
      2. 21.8.2 声明外来函数和变量
      3. 21.8.3 使用库函数
      4. 21.8.4 libgit2的原始接口
      5. 21.8.5 libgit2的安全接口 (1/2)
      6. 21.8.5 libgit2的安全接口 (2/2)
    9. 21.9 小结
  30. 作者介绍
  31. 封面介绍

Product information

  • Title: Rust 程序设计
  • Author(s): Jim Blandy, Jason Orendorff
  • Release date: September 2020
  • Publisher(s): Posts & Telecom Press
  • ISBN: 9787115546494

You might also like

book

Rust Programming By Example

by Guillaume Gomez, Antoni Boucher

Discover the world of Rust programming through real-world examples About This Book Implement various features of …

book

面向对象的思考过程（原书第5版）

by 马特 魏斯费尔德

本书是一部独具特色的面向对象技术著作。书中结合代码示例生动透彻地讲述了面向对象思想的精髓，让读者真正学会以对象方式进行思考。本书共15章，在结构上可以分为两部分：第壹部分包括第1~10章，探讨面向对象的基本概念，比如封装、多态、继承等；第二部分包括第11~15章，专注于将这些概念应用于一些通用的面向对象技术中，并结合了一些实用的应用程序。

video

Rust Fundamentals

by Alfredo Deza

Rust Fundamentals This course is ideal for beginners wanting to become proficient in Rust or from …

book

Linux 内核观测技术BPF

by David Calavera, Lorenzo Fontana

本书是一本面向系统工程师的实践指南，旨在帮助他们获得Linux内核中BPF虚拟机的专业知识。通过本书，你不仅可以深入了解BPF程序的生命周期，还可以学习编写观测和修改内核行为的应用程序，以及通过代码注入的方式对内核事件进行监控、跟踪和安全观测等内容。 作者David Calavera和Lorenzo Fontana希望帮助读者利用BPF技术提升计算机系统的可观测性。通过本书，你可以熟悉日常工作所需的基本概念，并增强有关性能优化、网络和安全方面的知识。同时，本书展示了相关的C、Go和Python代码示例。 根据需求编写使用BPF观测和修改Linux内核行为的应用程序。 在无须重新编译内核或重启系统的情况下，安全地注入代码对内核事件进行监控、跟踪和观测。 对C、Go和Python代码示例进行探索。 全面深入地了解BPF程序的生命周期。