1. 关于本书
  2. 进入 Rust 编程世界
  3. 避免从入门到放弃
  4. 社区和锈书
  7. BeatAI: 工程师 AI 入门圣经
  9. Rust 语言基础学习
  12. 寻找牛刀，以便小试
    ❱
    1. 安装 Rust 环境
    2. 墙推 VSCode!
    3. 认识 Cargo
    4. 不仅仅是 Hello world
    5. 下载依赖太慢了？
  14. Rust 基础入门
    ❱
    1. 变量绑定与解构
    2. 基本类型
      ❱
      1. 数值类型
      2. 字符、布尔、单元类型
      3. 语句与表达式
      4. 函数
    4. 所有权和借用
      ❱
      1. 所有权
      2. 引用与借用
    6. 复合类型
      ❱
      1. 字符串与切片
      2. 元组
      3. 结构体
      4. 枚举
      5. 数组
    8. 流程控制
    9. 模式匹配
      ❱
      1. match 和 if let
      2. 解构 Option
      3. 模式适用场景
      4. 全模式列表
    11. 方法 Method
    12. 泛型和特征
      ❱
      1. 泛型 Generics
      2. 特征 Trait
      3. 特征对象
      4. 进一步深入特征
    14. 集合类型
      ❱
      1. 动态数组 Vector
      2. KV 存储 HashMap
    16. 认识生命周期
    17. 返回值和错误处理
      ❱
      1. panic! 深入剖析
      2. 返回值 Result 和?
    19. 包和模块
      ❱
      1. 包 Crate
      2. 模块 Module
      3. 使用 use 引入模块及受限可见性
    21. 注释和文档
    22. 格式化输出
  16. 入门实战：文件搜索工具
    ❱
    1. 基本功能
    2. 增加模块化和错误处理
    3. 测试驱动开发
    4. 使用环境变量
    5. 重定向错误信息的输出
    6. 使用迭代器来改进程序(可选)
  19. Rust 语言进阶学习
  22. Rust 高级进阶
    ❱
    1. 生命周期
      ❱
      1. 深入生命周期
      2. &'static 和 T: 'static
    3. 函数式编程: 闭包、迭代器
      ❱
      1. 闭包 Closure
      2. 迭代器 Iterator
    5. 深入类型
      ❱
      1. 类型转换
      2. newtype 和 类型别名
      3. Sized 和不定长类型 DST
      4. 枚举和整数
    7. 智能指针
      ❱
      1. Box<T> 堆对象分配
      2. Deref 解引用
      3. Drop 释放资源
      4. Rc 与 Arc 实现 1vN 所有权机制
      5. Cell 与 RefCell 内部可变性
    9. 循环引用与自引用
      ❱
      1. Weak 与循环引用
      2. 结构体中的自引用
    11. 多线程并发编程
      ❱
      1. 并发和并行
      2. 使用多线程
      3. 线程同步：消息传递
      4. 线程同步：锁、Condvar 和信号量
      5. 线程同步：Atomic 原子操作与内存顺序
      6. 基于 Send 和 Sync 的线程安全
    13. 全局变量
    14. 错误处理
    15. Unsafe Rust
      ❱
      1. 五种兵器
      2. 内联汇编
    17. Macro 宏编程
    18. async/await 异步编程
      ❱
      1. async 编程入门
      2. 底层探秘: Future 执行与任务调度
      3. 定海神针 Pin 和 Unpin
      4. async/await 和 Stream 流处理
      5. 同时运行多个 Future
      6. 一些疑难问题的解决办法
      7. 实践应用：Async Web 服务器
  24. 进阶实战1: 实现一个 web 服务器
    ❱
    1. 单线程版本
    2. 多线程版本
    3. 优雅关闭和资源清理
  26. 进阶实战2: 实现一个简单 Redis
    ❱
    1. tokio 概览
    2. 使用初印象
    3. 创建异步任务
    4. 共享状态
    5. 消息传递
    6. I/O
    7. 解析数据帧
    8. 深入 async
    9. select
    10. 类似迭代器的 Stream
    11. 优雅的关闭
    12. 异步跟同步共存
  28. Rust 难点攻关
    ❱
    1. 切片和切片引用
    2. Eq 和 PartialEq
    3. String、&str 和 str TODO
    4. 作用域、生命周期和 NLL TODO
    5. move、Copy 和 Clone TODO
    6. 裸指针、引用和智能指针 TODO
  31. 常用工具链
  34. 自动化测试
    ❱
    1. 编写测试及控制执行
    2. 单元测试和集成测试
    3. 断言 assertion
    4. 用 GitHub Actions 进行持续集成
    5. 基准测试 benchmark
  36. Cargo 使用指南
    ❱
    1. 上手使用
    2. 基础指南
      ❱
      1. 为何会有 Cargo
      2. 下载并构建 Package
      3. 添加依赖
      4. Package 目录结构
      5. Cargo.toml vs Cargo.lock
      6. 测试和 CI
      7. Cargo 缓存
      8. Build 缓存
    4. 进阶指南
      ❱
      1. 指定依赖项
      2. 依赖覆盖
      3. Cargo.toml 清单详解
      4. Cargo Target
      5. 工作空间 Workspace
      6. 条件编译 Features
        ❱
        1. Features 示例
      8. 发布配置 Profile
      9. 通过 config.toml 对 Cargo 进行配置
      10. 发布到 crates.io
      11. 构建脚本 build.rs
        ❱
        1. 构建脚本示例
  39. 开发实践
  42. 企业落地实践
    ❱
    1. AWS 为何这么喜欢 Rust?
  44. 日志和监控
    ❱
    1. 日志详解
    2. 日志门面 log
    3. 使用 tracing 记录日志
    4. 自定义 tracing 的输出格式
    5. 监控
      ❱
      1. 可观测性
      2. 分布式追踪
  46. Rust 最佳实践
    ❱
    1. 日常开发三方库精选
    2. 命名规范
    3. 面试经验
    4. 代码开发实践 todo
  48. 手把手带你实现链表
    ❱
    1. 我们到底需不需要链表
    2. 不太优秀的单向链表：栈
      ❱
      1. 数据布局
      2. 基本操作
      3. 最后实现
    4. 还可以的单向链表
      ❱
      1. 优化类型定义
      2. 定义 Peek 函数
      3. IntoIter 和 Iter
      4. IterMut 以及完整代码
    6. 持久化单向链表
      ❱
      1. 数据布局和基本操作
      2. Drop、Arc 及完整代码
    8. 不咋样的双端队列
      ❱
      1. 数据布局和基本操作
      2. Peek
      3. 基本操作的对称镜像
      4. 迭代器
      5. 最终代码
    10. 不错的 unsafe 队列
      ❱
      1. 数据布局
      2. 基本操作
      3. Miri
      4. 栈借用
      5. 测试栈借用
      6. 数据布局 2
      7. 额外的操作
      8. 最终代码
    12. 生产级的双向 unsafe 队列
      ❱
      1. 数据布局
      2. 型变与子类型
      3. 基础结构
      4. 恐慌与安全
      5. 无聊的组合
      6. 其它特征
      7. 测试
      8. Send,Sync和编译测试
      9. 实现游标
      10. 测试游标
      11. 最终代码
    14. 使用高级技巧实现链表
      ❱
      1. 双单向链表
      2. 栈上的链表
  51. 攻克编译错误
  54. 征服编译错误
    ❱
    1. 对抗编译检查
      ❱
      1. 生命周期
        ❱
        1. 生命周期过大-01
        2. 生命周期过大-02
        3. 循环中的生命周期
        4. 闭包碰到特征对象-01
      3. 重复借用
        ❱
        1. 同时在函数内外使用引用
        2. 智能指针引起的重复借用错误
      5. 类型未限制(todo)
      6. 幽灵数据(todo)
    3. Rust 常见陷阱
      ❱
      1. for 循环中使用外部数组
      2. 线程类型导致的栈溢出
      3. 算术溢出导致的 panic
      4. 闭包中奇怪的生命周期
      5. 可变变量不可变？
      6. 可变借用失败引发的深入思考
      7. 不太勤快的迭代器
      8. 奇怪的序列 x..y
      9. 无处不在的迭代器
      10. 线程间传递消息导致主线程无法结束
      11. 警惕 UTF-8 引发的性能隐患
  57. 性能优化
  60. Rust 性能优化 todo
    ❱
    1. 深入内存 todo
      ❱
      1. 指针和引用 todo
      2. 未初始化内存 todo
      3. 内存分配 todo
      4. 内存布局 todo
      5. 虚拟内存 todo
    3. 性能调优 doing
      ❱
      1. 字符串操作性能
      2. 深入理解 move
      3. 糟糕的提前优化 todo
      4. Clone 和 Copy todo
      5. 减少 Runtime check(todo)
      6. CPU 缓存性能优化 todo
      7. 计算性能优化 todo
      8. 堆和栈 todo
      9. 内存 allocator todo
      10. 常用性能测试工具 todo
      11. Enum 内存优化 todo
    5. 编译优化 todo
      ❱
      1. LLVM todo
      2. 常见属性标记 todo
      3. 提升编译速度 todo
      4. 编译器优化 todo
        ❱
        1. Option 枚举 todo
  63. 附录
  66. Appendix
    ❱
    1. 关键字
    2. 运算符与符号
    3. 表达式
    4. 派生特征 trait
    5. prelude 模块 todo
    6. Rust 版本说明
    7. Rust 历次版本更新解读
      ❱
      1. 1.58
      2. 1.59
      3. 1.60
      4. 1.61
      5. 1.62
      6. 1.63
      7. 1.64
      8. 1.65
      9. 1.66
      10. 1.67
      11. 1.68
      12. 1.69
      13. 1.70
      14. 1.71
      15. 1.72
      16. 1.73
      17. 1.74
      18. 1.75
      19. 1.76
      20. 1.77
      21. 1.78
      22. 1.79
      23. 1.80
      24. 1.81
      25. 1.82
      26. 1.83
      27. 1.84
      28. 1.85
      29. 1.86