Skip to content

Commit

Permalink
Update perface.md
Browse files Browse the repository at this point in the history
  • Loading branch information
@DaviRain-Su
DaviRain-Su committed Apr 20, 2023
1 parent 7c54435 commit 7a664fd
Showing 1 changed file with 263 additions and 33 deletions.
296 changes: 263 additions & 33 deletions src/perface.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -719,39 +719,269 @@

### 4. 函数与模块

- 4.1. 函数定义与调用
- 4.1.1. 函数的基本语法
- 4.1.2. 参数与返回值
- 4.1.3. 函数调用
- 4.1.4. 函数重载与默认参数

- 4.2. 函数参数与返回值
- 4.2.1. 传值与传引用
- 4.2.2. 输出参数
- 4.2.3. 使用元组返回多个值
- 4.2.4. 返回闭包与函数指针

- 4.3. 模块与包
- 4.3.1. 模块定义与导入
- 4.3.2. 模块的可见性与公有接口
- 4.3.3. 使用包组织项目结构
- 4.3.4. 依赖管理与 Cargo.toml

- 4.4. 闭包与高阶函数
- 4.4.1. 闭包的定义与使用
- 4.4.2. 闭包捕获环境变量
- 4.4.3. 高阶函数与函数作为参数
- 4.4.4. 返回闭包与实现延迟执行

- 4.5. 函数与编译器优化
- 4.5.1. 编译器内联优化
- 4.5.2. 函数属性与编译器指令
- 4.5.3. 函数安全性与不安全代码

- 4.6. 测试与文档
- 4.6.1. 单元测试与集成测试
- 4.6.2. 使用 assert 宏进行断言
- 4.6.3. 文档注释与自动生成文档
- 4.1. 函数定义与调用
- 4.1.1. 函数简介
- 4.1.1.1. 什么是函数
- 4.1.1.2. 函数的作用与优势
- 4.1.1.3. Rust 中的函数特性

- 4.1.2. 定义函数
- 4.1.2.1. 函数的基本语法与结构
- 4.1.2.2. 函数参数与返回值
- 4.1.2.3. 函数签名与类型

- 4.1.3. 调用函数
- 4.1.3.1. 函数调用的基本语法
- 4.1.3.2. 函数调用的运行时行为
- 4.1.3.3. 函数调用与内存管理

- 4.1.4. 命名约定与可见性
- 4.1.4.1. 函数命名规范
- 4.1.4.2. 函数可见性与访问控制
- 4.1.4.3. pub 关键字与模块导入

- 4.1.5. 函数重载与泛型函数
- 4.1.5.1. 函数重载的概念与用途
- 4.1.5.2. Rust 中的泛型函数
- 4.1.5.3. 泛型函数与函数重载的关系

- 4.1.6. 高阶函数与闭包
- 4.1.6.1. 高阶函数的概念与用途
- 4.1.6.2. Rust 中的闭包
- 4.1.6.3. 高阶函数与闭包的使用场景

- 4.1.7. 函数式编程与Rust
- 4.1.7.1. 函数式编程简介
- 4.1.7.2. Rust 中的函数式编程特性
- 4.1.7.3. 函数式编程与Rust的优势

- 4.1.8. 实战：函数定义与调用
- 4.1.8.1. 使用函数简化代码结构
- 4.1.8.2. 函数与模块化设计
- 4.1.8.3. 高阶函数与闭包在实际项目中的应用

- 4.1.9. 函数定义与调用的最佳实践
- 4.1.9.1. 合理划分函数职责
- 4.1.9.2. 重用代码与泛型函数
- 4.1.9.3. 注意函数调用的性能与资源消耗

- 4.2. 函数参数与返回值
- 4.2.1. 函数参数概述
- 4.2.1.1. 什么是函数参数
- 4.2.1.2. 函数参数的作用与优势
- 4.2.1.3. Rust 中的函数参数特性

- 4.2.2. 定义函数参数
- 4.2.2.1. 参数类型与顺序
- 4.2.2.2. 参数的默认值与可选参数
- 4.2.2.3. 可变参数列表

- 4.2.3. 函数参数的传递方式
- 4.2.3.1. 值传递与引用传递
- 4.2.3.2. Rust 中的所有权传递
- 4.2.3.3. 函数参数传递与内存管理

- 4.2.4. 返回值概述
- 4.2.4.1. 什么是返回值
- 4.2.4.2. 返回值的作用与优势
- 4.2.4.3. Rust 中的返回值特性

- 4.2.5. 定义返回值
- 4.2.5.1. 返回值的类型
- 4.2.5.2. 显式与隐式返回值
- 4.2.5.3. 多返回值与元组

- 4.2.6. 错误处理与返回值
- 4.2.6.1. 错误处理的重要性
- 4.2.6.2. Rust 中的 Result 与 Option 类型
- 4.2.6.3. 利用返回值进行错误处理

- 4.2.7. 函数参数与返回值的性能考虑
- 4.2.7.1. 参数传递与性能
- 4.2.7.2. 返回值与性能
- 4.2.7.3. 优化技巧与最佳实践

- 4.2.8. 实战：函数参数与返回值
- 4.2.8.1. 设计函数接口
- 4.2.8.2. 错误处理与返回值
- 4.2.8.3. 性能优化实践

- 4.2.9. 函数参数与返回值的最佳实践
- 4.2.9.1. 合理使用参数与返回值
- 4.2.9.2. 注意内存管理与性能
- 4.2.9.3. 使用错误处理类型提高代码可靠性



- 4.3. 模块与包
- 4.3.1. 模块与包概述
- 4.3.1.1. 什么是模块与包
- 4.3.1.2. 模块与包的作用与优势
- 4.3.1.3. Rust 中的模块与包特性

- 4.3.2. 定义模块
- 4.3.2.1. 创建模块的基本语法与结构
- 4.3.2.2. 模块中的函数、结构体和枚举
- 4.3.2.3. 模块的可见性与访问控制

- 4.3.3. 使用模块
- 4.3.3.1. 模块导入的基本语法
- 4.3.3.2. 使用模块中的成员
- 4.3.3.3. 重新导出与模块组织

- 4.3.4. 定义包
- 4.3.4.1. 创建包的基本结构
- 4.3.4.2. 包中的模块与文件组织
- 4.3.4.3. 包的元数据与Cargo.toml

- 4.3.5. 使用包
- 4.3.5.1. 导入包的基本语法
- 4.3.5.2. 使用包中的成员
- 4.3.5.3. 包版本管理与依赖解析

- 4.3.6. 发布与共享包
- 4.3.6.1. 创建可发布的包
- 4.3.6.2. 发布到 crates.io
- 4.3.6.3. 使用其他人的包与包管理工具

- 4.3.7. 工作空间与多包项目
- 4.3.7.1. Rust 工作空间简介
- 4.3.7.2. 创建与配置工作空间
- 4.3.7.3. 多包项目的构建与依赖管理

- 4.3.8. 实战：模块与包
- 4.3.8.1. 设计模块化的项目结构
- 4.3.8.2. 创建自定义包
- 4.3.8.3. 使用第三方包进行开发

- 4.3.9. 模块与包的最佳实践
- 4.3.9.1. 合理划分模块与包
- 4.3.9.2. 注意包的版本管理与依赖关系
- 4.3.9.3. 优化项目结构与模块组织

- 4.4. 闭包与高阶函数
- 4.4.1. 闭包概述
- 4.4.1.1. 什么是闭包
- 4.4.1.2. 闭包的作用与优势
- 4.4.1.3. Rust 中的闭包特性

- 4.4.2. 定义与使用闭包
- 4.4.2.1. 闭包的基本语法与结构
- 4.4.2.2. 闭包的捕获方式与环境
- 4.4.2.3. 闭包类型推断与显式类型注解

- 4.4.3. 闭包与函数的比较
- 4.4.3.1. 闭包与函数的相似性与区别
- 4.4.3.2. 选择闭包或函数的场景与依据
- 4.4.3.3. 闭包与函数性能的对比

- 4.4.4. 高阶函数概述
- 4.4.4.1. 什么是高阶函数
- 4.4.4.2. 高阶函数的作用与优势
- 4.4.4.3. Rust 中的高阶函数特性

- 4.4.5. 使用高阶函数
- 4.4.5.1. 高阶函数的基本语法与结构
- 4.4.5.2. 传递闭包与函数作为参数
- 4.4.5.3. 返回闭包与函数作为结果

- 4.4.6. 常见高阶函数与应用场景
- 4.4.6.1. map、filter 和 fold
- 4.4.6.2. 自定义高阶函数与实现模式
- 4.4.6.3. 高阶函数在实际项目中的应用

- 4.4.7. 实战：闭包与高阶函数
- 4.4.7.1. 使用闭包处理数据集合
- 4.4.7.2. 创建自定义高阶函数
- 4.4.7.3. 优化代码结构与逻辑

- 4.4.8. 闭包与高阶函数的最佳实践
- 4.4.8.1. 合理使用闭包与高阶函数
- 4.4.8.2. 注意闭包的性能与内存管理
- 4.4.8.3. 优化高阶函数的实现与使用

- 4.5. 函数与编译器优化
- 4.5.1. 函数优化概述
- 4.5.1.1. 函数优化的目标与意义
- 4.5.1.2. 函数优化涉及的方面
- 4.5.1.3. Rust 编译器对函数优化的支持

- 4.5.2. 内联函数
- 4.5.2.1. 什么是内联函数
- 4.5.2.2. 内联函数的优势与劣势
- 4.5.2.3. Rust 中的内联函数与指令

- 4.5.3. 递归与尾递归优化
- 4.5.3.1. 递归函数的基本概念与应用
- 4.5.3.2. 尾递归的概念与优势
- 4.5.3.3. Rust 编译器对尾递归的优化

- 4.5.4. 代码剖析与性能分析
- 4.5.4.1. 使用编译器标志分析代码
- 4.5.4.2. 利用性能分析工具定位瓶颈
- 4.5.4.3. 优化函数性能的实践

- 4.5.5. 编译器优化技术
- 4.5.5.1. 常量折叠与常量传播
- 4.5.5.2. 循环优化与展开
- 4.5.5.3. 其他编译器优化技术与Rust特性

- 4.5.6. 优化级别与构建策略
- 4.5.6.1. Rust 编译器的优化级别
- 4.5.6.2. 选择合适的优化级别与目标
- 4.5.6.3. 构建策略与发布模式

- 4.5.7. 实战：函数与编译器优化
- 4.5.7.1. 使用内联函数优化性能
- 4.5.7.2. 将递归转化为尾递归
- 4.5.7.3. 选择合适的优化级别与构建策略

- 4.5.8. 函数与编译器优化的最佳实践
- 4.5.8.1. 在性能与可读性间取得平衡
- 4.5.8.2. 合理利用编译器优化
- 4.5.8.3. 注重代码性能与资源消耗的平衡

- 4.6. 测试与文档
- 4.6.1. 测试概述
- 4.6.1.1. 测试的目标与意义
- 4.6.1.2. 测试的种类与范围
- 4.6.1.3. Rust 中的测试支持与特性

- 4.6.2. 单元测试
- 4.6.2.1. 什么是单元测试
- 4.6.2.2. 单元测试的编写与运行
- 4.6.2.3. Rust 中的单元测试组织与管理

- 4.6.3. 集成测试
- 4.6.3.1. 什么是集成测试
- 4.6.3.2. 集成测试的编写与运行
- 4.6.3.3. Rust 中的集成测试组织与管理

- 4.6.4. 文档测试
- 4.6.4.1. 什么是文档测试
- 4.6.4.2. 文档测试的编写与运行
- 4.6.4.3. Rust 中的文档测试组织与管理

- 4.6.5. 持续集成与自动化测试
- 4.6.5.1. 持续集成的概念与意义
- 4.6.5.2. Rust 项目中的持续集成工具与流程
- 4.6.5.3. 自动化测试在 Rust 项目中的应用

- 4.6.6. 文档编写与维护
- 4.6.6.1. 文档的重要性与分类
- 4.6.6.2. Rust 中的文档注释与生成
- 4.6.6.3. 文档的编写规范与最佳实践

- 4.6.7. 实战：测试与文档
- 4.6.7.1. 编写与优化单元测试
- 4.6.7.2. 创建集成测试与文档测试
- 4.6.7.3. 配置持续集成与自动化测试
- 4.6.7.4. 编写高质量的文档

- 4.6.8. 测试与文档的最佳实践
- 4.6.8.1. 测试驱动开发与代码质量
- 4.6.8.2. 持续集成与敏捷开发
- 4.6.8.3. 文档的重要性与维护策略

- 4.7. 小结与思考题

Expand Down

0 comments on commit 7a664fd

Please sign in to comment.