Merge pull request #15 from sunface/main

sync
pull/1126/head
Rustln 3 years ago committed by GitHub
commit b32104d898
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

@ -7,7 +7,7 @@
---
[Rust 语言中文网](community.md)
[一本生锈的书](rusty-book.md)
[Rust 语言周刊第 10 期](rust-weekly.md)
[Rust 语言周刊](rust-weekly.md)
[Rust 翻译计划( 代号 Rustt )](rustt.md)
# 快速开始

@ -119,7 +119,7 @@ macro_rules! vec {
首先,我们使用圆括号 `()` 将整个宏模式包裹其中。紧随其后的是 `$()`,跟括号中模式相匹配的值(传入的 Rust 源代码)会被捕获,然后用于代码替换。在这里,模式 `$x:expr` 会匹配任何 Rust 表达式并给予该模式一个名称:`$x`。
`$()` 之后的逗号说明在 `$()` 所匹配的代码的后面会有一个可选的逗号分隔符,紧随逗号之后的 `*` 说明 `*` 之前的模式会被匹配次或任意多次(类似正则表达式)。
`$()` 之后的逗号说明在 `$()` 所匹配的代码的后面会有一个可选的逗号分隔符,紧随逗号之后的 `*` 说明 `*` 之前的模式会被匹配次或任意多次(类似正则表达式)。
当我们使用 `vec![1, 2, 3]` 来调用该宏时,`$x` 模式将被匹配三次,分别是 `1`、`2`、`3`。为了帮助大家巩固,我们再来一起过一下:

@ -179,3 +179,7 @@ let home: IpAddr = "127.0.0.1".parse().unwrap();
还有一种情况,在展开过程中,如果展开本身 `panic` 了,那展开线程会终止,展开也随之停止。
一旦线程展开被终止或者完成,最终的输出结果是取决于哪个线程 `panic`:对于 `main` 线程,操作系统提供的终止功能 `core::intrinsics::abort()` 会被调用,最终结束当前的 `panic` 进程;如果是其它子线程,那么子线程就会简单的终止,同时信息会在稍后通过 `std::thread::join()` 进行收集。
## 课后练习
> [Rust By Practice](https://zh.practice.rs/result-panic/panic.html),支持代码在线编辑和运行,并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。

@ -385,3 +385,7 @@ let x = try!(function_with_error());
可以看出 `?` 的优势非常明显,何况 `?` 还能做链式调用。
总之,`try!` 作为前浪已经死在了沙滩上,**在当前版本中,我们要尽量避免使用 try!**。
## 课后练习
> [Rust By Practice](https://zh.practice.rs/result-panic/result.html),支持代码在线编辑和运行,并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。

@ -73,6 +73,8 @@ Hello, world!
好了,你已经看到程序的输出:`"Hello, world"`。
如果你安装的 Rust 的 `host triple``x86_64-pc-windows-msvc` 并确认 Rust 已经正确安装,但在终端上运行上述命令时,出现类似如下的错误摘要 `` linking with `link.exe` failed: exit code: 1181 ``,请使用 Visual Studio Installer 安装 `Windows SDK`
可能有读者不愿意了,说好了"世界,你好"呢?别急,在下一节,我们再对代码进行修改。(认真想来,"你好,世界“强调的是我对世界说你好,而"世界,你好“是世界对我说你好,明显是后者更有包容性和国际范儿,读者真·好眼光。)
上述代码,`cargo run` 首先对项目进行编译,然后再运行,因此它实际上等同于运行了两个指令,下面我们手动试一下编译和运行项目:
@ -171,4 +173,3 @@ geometry = { path = "crates/geometry" }
前文有提到 `cargo` 默认生成的项目结构,真实的项目肯定会有所不同,但是在目前的学习阶段,还无需关注。感兴趣的同学可以移步:[Cargo 项目结构](https://course.rs/cargo/guide/package-layout.html)
至此,大家对 Rust 项目的创建和管理已经有了初步的了解,那么来完善刚才的`"世界,你好"`项目吧。

@ -49,7 +49,9 @@ Windows 上安装 Rust 需要有 `C++` 环境,以下为安装的两种方式
**1. `x86_64-pc-windows-msvc`(官方推荐)**
先安装 [Microsoft C++ Build Tools](https://visualstudio.microsoft.com/zh-hans/visual-cpp-build-tools/),安装勾选 C++ 环境即可。安装时 可自行修改缓存路径与安装路径,避免占用过多 C 盘空间。
先安装 [Microsoft C++ Build Tools](https://visualstudio.microsoft.com/zh-hans/visual-cpp-build-tools/),勾选安装 C++ 环境即可。安装时可自行修改缓存路径与安装路径,避免占用过多 C 盘空间。安装完成后Rust 所需的 msvc 命令行程序需要手动添加到环境变量中,否则安装 Rust 时 `rustup-init` 会提示未安装 Microsoft C++ Build Tools其位于`%Visual Studio 安装位置%\VC\Tools\MSVC\%version%\bin\Hostx64\x64`(请自行替换其中的 %Visual Studio 安装位置%、%version% 字段)下。
如果你不想这么做,可以选择安装 Microsoft C++ Build Tools 新增的“定制”终端 `Developer Command Prompt for %Visual Studio version%``Developer PowerShell for %Visual Studio version%`,在其中运行 `rustup-init.exe`
准备好 C++ 环境后开始安装 Rust
@ -162,4 +164,3 @@ cargo 1.57.0 (b2e52d7ca 2021-10-21)
安装 Rust 的同时也会在本地安装一个文档服务,方便我们离线阅读:运行 `rustup doc` 让浏览器打开本地文档。
每当遇到标准库提供的类型或函数不知道怎么用时,都可以在 API 文档中查找到!具体参见 [在标准库寻找你想要的内容](https://course.rs/std/search.html)。

@ -10,41 +10,44 @@
<a id="head"></a>
| NN | NN | NN | NN | NN | NN | NN | NN | NN | NN | NN | NN |
| :-------------: | :-----: | :-----: | :-----: | :-----: | :-----: | :-----: | :-----: | :-----: | :-----: | :-----: | :-----: |
| [Sym](#sym) | [A](#a) | [B](#b) | [C](#c) | [D](#d) | [E](#e) | [F](#f) | [G](#g) | [H](#h) | [I](#i) | [J](#j) | [K](#k) |
| [Cargo](#cargo) | [L](#l) | [M](#m) | [N](#n) | [O](#o) | [P](#p) | [Q](#q) | [R](#r) | [S](#s) | [T](#t) | [U](#u) | [V](#v) |
| [W](#w) | [X](#x) | [Y](#y) | [Z](#z) |
| NN | NN | NN | NN | NN | NN | NN | NN | NN | NN | NN |
| :-------------: | :------: | :-----: | :-----: | :-----: | :-----: | :-----: | :-----: | :-----: | :-----: | :-----: |
| [#](#sym) | [A](#a) | [B](#b) | [C](#c) | [D](#d) | [E](#e) | [F](#f) | [G](#g) | [H](#h) | [I](#i) | [J](#j) |
| [K](#k) | [L](#l) | [M](#m) | [N](#n) | [O](#o) | [P](#p) | [Q](#q) | [R](#r) | [S](#s) | [T](#t) | [U](#u) |
| [V](#v) | [W](#w) | [X](#x) | [Y](#y) | [Z](#z) |
| [Cargo](#cargo) | [Naming] |
[naming]: https://course.rs/practice/naming.html
[bottom](#bottom)
## Sym
| 名称 | 关键字 | 简介 |
| ------------------------------- | -------------- | ------------------------------------------------------------------------------------ |
| [?] | 错误传播 | 用于简化错误传播 |
| [()] | 单元类型 | 单元类型,无返回值 |
| `!` : [1 函数] [2 类型] | 永不返回 | 永不返回 |
| [&] | 引用 | 常规引用是一个指针类型,指向了对象存储的内存地址 |
| [\*] | 解引用 | 解出引用所指向的值 |
| [@] | 变量绑定 | 为一个字段绑定另外一个变量 |
| `_` : [1 忽略变量] [2 模式匹配] | 忽略 | 1. 忽略该值或者类型,否则编译器会给你一个 `变量未使用的` 的警告<br>2. 模式匹配通配符 |
| ['a: 'b] | 生命周期约束 | 用来说明两个生命周期的长短 |
| [{:?}] {:#?} | 打印结构体信息 | 使用 `#[derive(Debug)]` 派生实现 `Debug` 特征 |
| [::] | 关联函数 | 定义在 `impl` 中且没有 `self` 的函数 |
| A | | AIntroduction |
| 名称 | 关键字 | 简介 |
| --------------------------------- | -------------- | ------------------------------------------------------------------------------------ |
| [?] | 错误传播 | 用于简化错误传播 |
| [()] | 单元类型 | 单元类型,无返回值 |
| `!` : 1. [函数] 2. [类型] | 永不返回 | 永不返回 |
| [&] | 引用 | 常规引用是一个指针类型,指向了对象存储的内存地址 |
| [\*] | 解引用 | 解出引用所指向的值 |
| [@] | 变量绑定 | 为一个字段绑定另外一个变量 |
| `_` : 1. [忽略变量] 2. [模式匹配] | 忽略 | 1. 忽略该值或者类型,否则编译器会给你一个 `变量未使用的` 的警告<br>2. 模式匹配通配符 |
| ['a: 'b] | 生命周期约束 | 用来说明两个生命周期的长短 |
| [{:?}] {:#?} | 打印结构体信息 | 使用 `#[derive(Debug)]` 派生实现 `Debug` 特征 |
| [::] | 关联函数 | 定义在 `impl` 中且没有 `self` 的函数 |
| | |
[?]: https://course.rs/basic/result-error/result.html#传播界的大明星-
[()]: https://course.rs/basic/base-type/function.html#无返回值
[1 函数]: https://course.rs/basic/base-type/function.html#永不返回的发散函数-
[2 类型]: https://course.rs/advance/into-types/custom-type.html#永不返回类型
[函数]: https://course.rs/basic/base-type/function.html#永不返回的发散函数-
[类型]: https://course.rs/advance/into-types/custom-type.html#永不返回类型
[&]: https://course.rs/basic/ownership/borrowing.html#引用与解引用
[\*]: https://course.rs/basic/ownership/borrowing.html#引用与解引用
[@]: https://course.rs/basic/match-pattern/all-patterns.html#绑定
['a: 'b]: https://course.rs/advance/lifetime/advance.html#生命周期约束-hrtb
[{:?}]: https://course.rs/basic/compound-type/struct.html?search=#使用-derivedebug-来打印结构体的信息
[1 忽略变量]: https://course.rs/basic/variable.html#使用下划线开头忽略未使用的变量
[2 模式匹配]: https://course.rs/basic/match-pattern/match-if-let.html#_-通配符
[{:?}]: https://course.rs/basic/compound-type/struct.html#使用-derivedebug-来打印结构体的信息
[忽略变量]: https://course.rs/basic/variable.html#使用下划线开头忽略未使用的变量
[模式匹配]: https://course.rs/basic/match-pattern/match-if-let.html#_-通配符
[::]: https://course.rs/basic/method.html#关联函数
[back](#head)
@ -55,7 +58,7 @@
| ------------- | -------- | ---------------------------------------------------------------------------------------------------------------------- |
| [array 数组] | 数组 | 长度固定<br>元素必须有相同的类型<br>依次线性排列<br>可以通过索引访问其中的元素<br>`let a: [i32; 5] = [1, 2, 3, 4, 5];` |
| [array slice] | 数组切片 | `let slice: &[i32] = &a[1..3];` |
| A | KWA | AIntroduction |
| | KWA | |
[array 数组]: https://course.rs/basic/compound-type/array.html
[array slice]: https://course.rs/basic/compound-type/array.html#数组切片
@ -72,7 +75,7 @@
| [表达式] | | 进行求值,结尾无 `;`,有返回值 |
| [bool 布尔] | 布尔类型 | `true` `false`,占用 1 字节 |
| [break] | 循环控制 | 直接跳出当前整个循环 |
| B | KWB | BIntroduction |
| | KWB | |
[变量遮蔽]: https://course.rs/basic/variable.html#变量遮蔽shadowing
[变量覆盖]: https://course.rs/basic/match-pattern/match-if-let.html#变量覆盖
@ -85,28 +88,36 @@
## C
| 名称 | 关键字 | 简介 |
| ------------ | -------- | ----------------------------------------------------------------------------------- |
| [char 字符] | 字符类型 | 使用 `''` 表示,所有的 Unicode 值 |
| [const 常量] | constant | `const MAX_POINTS: u32 = 100_000;` |
| [Copy 拷贝] | 浅拷贝 | 任何基本类型的组合可以 `Copy`,不需要分配内存或某种形式资源的类型是可以 `Copy` 的。 |
| [continue] | 循环控制 | 跳过当前当次的循环,开始下次的循环 |
| [Clone 克隆] | 深拷贝 | 需要复制堆上的数据时,可以使用 `.clone()` 方法 |
| C | KWC | CIntroduction |
| 名称 | 关键字 | 简介 |
| ------------------ | -------- | ----------------------------------------------------------------------------------- |
| [char 字符] | 字符类型 | 使用 `''` 表示,所有的 Unicode 值 |
| [const 常量] | constant | `const MAX_POINTS: u32 = 100_000;` |
| [const 泛型] | 泛型 | `const N: usize` 针对值的泛型,适合处理数组长度的问题 |
| [const 泛型表达式] | 泛型 | |
| [Copy 拷贝] | 浅拷贝 | 任何基本类型的组合可以 `Copy`,不需要分配内存或某种形式资源的类型是可以 `Copy` 的。 |
| [continue] | 循环控制 | 跳过当前当次的循环,开始下次的循环 |
| [Clone 克隆] | 深拷贝 | 需要复制堆上的数据时,可以使用 `.clone()` 方法 |
| | KWC | |
[char 字符]: https://course.rs/basic/base-type/char-bool.html#字符类型char
[const 常量]: https://course.rs/basic/variable.html#变量和常量之间的差异
[copy 拷贝]: https://course.rs/basic/ownership/ownership.html#拷贝浅拷贝
[clone 克隆]: https://course.rs/basic/ownership/ownership.html#克隆深拷贝
[continue]: https://course.rs/basic/flow-control.html#continue
[const 泛型]: https://course.rs/basic/trait/generic.html#const-泛型rust-151-版本引入的重要特性
[const 泛型表达式]: https://course.rs/basic/trait/generic.html#const-泛型表达式
[back](#head)
## D
| 名称 | 关键字 | 简介 |
| ---- | ------ | ------------- |
| D | KWD | DIntroduction |
| 名称 | 关键字 | 简介 |
| -------- | -------- | ----------------------------------------------------------------------------------- |
| [derive] | 派生特征 | `#[derive(Trait)]`,被标记的对象自动实现对应的默认特征代码<br>详见:[附录-派生特征] |
| | KWD | |
[derive]: https://course.rs/basic/trait/trait.html#通过-derive-派生特征
[附录-派生特征]: https://course.rs/appendix/derive.html
[back](#head)
@ -116,7 +127,7 @@
| ----------------- | -------- | ---------------------------------------- |
| [enum 枚举] | 枚举类型 | 允许通过列举可能的成员来定义一个枚举类型 |
| [enum 同一化类型] | 枚举方法 | 枚举实现方法 |
| E | KWE | EIntroduction |
| | KWE | |
[enum 枚举]: https://course.rs/basic/compound-type/enum.html#枚举
[enum 同一化类型]: https://course.rs/basic/compound-type/enum.html#同一化类型
@ -125,64 +136,72 @@
## F
| 名称 | 关键字 | 简介 |
| ---------- | -------- | ---------------------------- |
| [浮点数] | 数值类型 | `f32`<br>`f64`(默认类型) |
| [for 循环] | 循环控制 | `for item in &collection {}` |
| F | KWF | FIntroduction |
| 名称 | 关键字 | 简介 |
| ---------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [浮点数] | 数值类型 | `f32`<br>`f64`(默认类型) |
| [for 循环] | 循环控制 | `for item in &collection {}` |
| ['fn' 函数] | | 函数名和变量名使用 `蛇形命名法(snake case)`<br>函数的位置可以随便放<br>每个函数参数都需要标注类型 |
| [调用同名的方法] | | 1. 默认调用类型上的方法<br>`Struct.function(receiver_if_method, next_arg, ...);`<br>2. 显式调用特征上的方法<br>`Trait::function(receiver_if_method, next_arg, ...);`<br>3. [完全限定语法]<br>`<Type as Trait>::function(receiver_if_method, next_arg, ...);` |
| | KWF | |
[浮点数]: https://course.rs/basic/base-type/numbers.html#浮点类型
[for 循环]: https://course.rs/basic/flow-control.html#for-循环
['fn' 函数]: https://course.rs/basic/base-type/function.html
[调用同名的方法]: https://course.rs/basic/trait/advance-trait.html#调用同名的方法
[完全限定语法]: https://course.rs/basic/trait/advance-trait.html#完全限定语法
[back](#head)
## G
| 名称 | 关键字 | 简介 |
| ---- | ------ | ------------- |
| G | KWG | GIntroduction |
| 名称 | 关键字 | 简介 |
| --------------- | ------ | ---------------------------------- |
| [Generics 泛型] | 泛型 | 用同一功能的函数处理不同类型的数据 |
| | KWG | |
[generics 泛型]: https://course.rs/basic/trait/generic.html
[back](#head)
## H
| 名称 | 关键字 | 简介 |
| ------ | ------ | ------------------------------------------------------------------------------------------------- |
| [函数] | `fn` | 函数名和变量名使用 `蛇形命名法(snake case)`<br>函数的位置可以随便放<br>每个函数参数都需要标注类型 |
| H | KWH | HIntroduction |
[函数]: https://course.rs/basic/base-type/function.html
| 名称 | 关键字 | 简介 |
| ---- | ------ | ---- |
| | KWH | |
[back](#head)
## I
| 名称 | 关键字 | 简介 |
| ------------- | -------- | --------------------------------------------------------------------- |
| [if else] | 流程控制 | 根据条件执行不同的代码分支 |
| [else if] | 流程控制 | 处理多重条件 |
| [if let 匹配] | 模式匹配 | 当你只要匹配一个条件,且忽略其他条件时就用 `if let`,否则都用 `match` |
| I | KWI | IIntroduction |
| 名称 | 关键字 | 简介 |
| -------------------------------------------- | -------- | --------------------------------------------------------------------- |
| [if else] | 流程控制 | 根据条件执行不同的代码分支 |
| [else if] | 流程控制 | 处理多重条件 |
| [if let 匹配] | 模式匹配 | 当你只要匹配一个条件,且忽略其他条件时就用 `if let`,否则都用 `match` |
| `impl Trait` 1. [函数参数] 2. [函数返回类型] | | |
| | KWI | |
[if else]: https://course.rs/basic/flow-control.html#使用-if-来做分支控制
[else if]: https://course.rs/basic/flow-control.html#使用-else-if-来处理多重条件
[if let 匹配]: https://course.rs/basic/match-pattern/match-if-let.html#if-let-匹配
[函数参数]: https://course.rs/basic/trait/trait.html#使用特征作为函数参数
[函数返回类型]: https://course.rs/basic/trait/trait.html#函数返回中的-impl-trait
[back](#head)
## J
| 名称 | 关键字 | 简介 |
| ---- | ------ | ------------- |
| J | KWJ | JIntroduction |
| 名称 | 关键字 | 简介 |
| ---- | ------ | ---- |
| | KWJ | |
[back](#head)
## K
| 名称 | 关键字 | 简介 |
| ---- | ------ | ------------- |
| K | KWK | KIntroduction |
| 名称 | 关键字 | 简介 |
| ---- | ------ | ---- |
| | KWK | |
[back](#head)
@ -193,7 +212,7 @@
| [let] | 变量绑定 | `let x : u32 = 5;` |
| [let mut] | 可变变量 | `let mut x : u32 = 5; x = 9;` |
| [loop 循环] | 循环控制 | 无限循环,注意要配合 [`break`] |
| L | KWL | LIntroduction |
| | KWL | |
[let]: https://course.rs/basic/variable.html#变量绑定
[let mut]: https://course.rs/basic/variable.html#变量可变性
@ -204,17 +223,17 @@
## M
| 名称 | 关键字 | 简介 |
| --------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [模式绑定] | 模式匹配 | 从模式中取出绑定的值 |
| [全模式列表] | 模式匹配 | 列出了所有的模式匹配 |
| [Method 方法] | `impl` | Rust 的方法往往跟结构体、枚举、特征一起使用 |
| [Method getter] | `getter` | 方法名跟结构体的字段名相同 |
| [match 匹配] | 模式匹配 | `match` 的匹配必须要穷举出所有可能,因此这里用 `_ ` 来代表未列出的所有可能性<br>`match` 的每一个分支都必须是一个表达式,且所有分支的表达式最终返回值的类型必须相同 |
| [matches! 宏] | 模式匹配 | 将一个表达式跟模式进行匹配,然后返回匹配的结果 `true``false` |
| [match guard] | 匹配守卫 | 位于 `match` 分支模式之后的额外 `if` 条件,它能为分支模式提供更进一步的匹配条件 |
| [move 移动] | 转移所有权 | `let s2 = s1;`<br>`s1` 所有权转移给了 `s2``s1` 失效 |
| M | KWM | MIntroduction |
| 名称 | 关键字 | 简介 |
| --------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [模式绑定] | 模式匹配 | 从模式中取出绑定的值 |
| [全模式列表] | 模式匹配 | 列出了所有的模式匹配 |
| [Method 方法] | `impl` | Rust 的方法往往跟结构体、枚举、特征一起使用 |
| [Method getter] | `getter` | 方法名跟结构体的字段名相同 |
| [match 匹配] | 模式匹配 | 1. `match` 的匹配必须要穷举出所有可能,因此这里用 `_ ` 来代表未列出的所有可能性<br>2. `match` 的每一个分支都必须是一个表达式,且所有分支的表达式最终返回值的类型必须相同 |
| [matches! 宏] | 模式匹配 | 将一个表达式跟模式进行匹配,然后返回匹配的结果 `true``false` |
| [match guard] | 匹配守卫 | 位于 `match` 分支模式之后的额外 `if` 条件,它能为分支模式提供更进一步的匹配条件 |
| [move 移动] | 转移所有权 | `let s2 = s1;`<br>`s1` 所有权转移给了 `s2``s1` 失效 |
| | KWM | |
[模式绑定]: https://course.rs/basic/match-pattern/match-if-let.html#模式绑定
[match 匹配]: https://course.rs/basic/match-pattern/match-if-let.html#match-匹配
@ -229,9 +248,13 @@
## N
| 名称 | 关键字 | 简介 |
| ---- | ------ | ------------- |
| N | KWN | NIntroduction |
| 名称 | 关键字 | 简介 |
| --------- | ------ | ------------------------------------------------------------------------------------------ |
| [newtype] | | 为一个[元组结构体]创建新类型。该元组结构体封装有一个字段,该字段就是希望实现特征的具体类型 |
| | KWN | |
[newtype]: https://course.rs/basic/trait/advance-trait.html#在外部类型上实现外部特征newtype
[元组结构体]: https://course.rs/basic/compound-type/struct.html#元组结构体tuple-struct
[back](#head)
@ -241,7 +264,7 @@
| ------------- | ----------- | --------------------------------------------------------------- |
| [Option] | Option 枚举 | 用于处理空值,**一个变量要么有值:`Some(T)`, 要么为空:`None`** |
| [Option 解构] | 模式匹配 | 可以通过 `match` 来实现 |
| O | KWO | OIntroduction |
| | KWO | |
[option]: https://course.rs/basic/compound-type/enum.html#option-枚举用于处理空值
[option 解构]: https://course.rs/basic/match-pattern/option.html#匹配-optiont
@ -250,17 +273,17 @@
## P
| 名称 | 关键字 | 简介 |
| ---- | ------ | ------------- |
| P | KWP | PIntroduction |
| 名称 | 关键字 | 简介 |
| ---- | ------ | ---- |
| | KWP | |
[back](#head)
## Q
| 名称 | 关键字 | 简介 |
| ---- | ------ | ------------- |
| Q | KWQ | QIntroduction |
| 名称 | 关键字 | 简介 |
| ---- | ------ | ---- |
| | KWQ | |
[back](#head)
@ -269,7 +292,7 @@
| 名称 | 关键字 | 简介 |
| ------------ | ------ | ---------------------------------------------------------------------------------- |
| [Range 序列] | | 生成连续的数值<br> 只允许用于数字或字符类型<br> `..` 右半开区间 <br>`..=` 闭合区间 |
| R | KWR | RIntroduction |
| | KWR | |
[range 序列]: https://course.rs/basic/base-type/numbers.html#序列range
@ -287,7 +310,8 @@
| [String 转义] | `String` 方法 | 通过转义的方式 `\` 输出 ASCII 和 Unicode 字符 |
| [struct 结构体] | 结构体 | 通过关键字 `struct` 定义<br>一个清晰明确的结构体 `名称`<br>几个有名字的结构体 `字段`<br>通过 `.` 访问字段 |
| [self &self &mut self] | Method 方法 | `self` 指代类型的实例 |
| S | KWS | SIntroduction |
| [Self 与 self] | | `self` 指代当前的实例对象,`Self` 指代特征或者方法类型的别名 |
| | KWS | |
[所有权与堆栈]: https://course.rs/basic/ownership/ownership.html#所有权与堆栈
[所有权原则]: https://course.rs/basic/ownership/ownership.html#所有权原则
@ -297,19 +321,31 @@
[string 转义]: https://course.rs/basic/compound-type/string-slice.html#字符串转义
[struct 结构体]: https://course.rs/basic/compound-type/struct.html
[self &self &mut self]: https://course.rs/basic/method.html#selfself-和-mut-self
[self 与 self]: https://course.rs/basic/trait/trait-object#self-与-self
[back](#head)
## T
| 名称 | 关键字 | 简介 |
| -------------- | ---------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Tuple 元组] | | 由多种类型组合一起,元组的长度是固定的,元组中元素的顺序也是固定的<br>用模式匹配解构元组:`let (x, y, z) = (20, 19.2, 1)`<br>`.` 来访问元组:`tuple.0` 索引从 0 开始 |
| [Tuple Struct] | 元组结构体 | 结构体必须要有名称,但字段可以没有名称<br>`struct Color(i32, i32, i32);` |
| T | KWT | TIntroduction |
| 名称 | 关键字 | 简介 |
| ------------------------------------------ | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Tuple 元组] | | 由多种类型组合一起,元组的长度是固定的,元组中元素的顺序也是固定的<br>用模式匹配解构元组:`let (x, y, z) = (20, 19.2, 1)`<br>`.` 来访问元组:`tuple.0` 索引从 0 开始 |
| [Tuple Struct] | 元组结构体 | 结构体必须要有名称,但字段可以没有名称<br>`struct Color(i32, i32, i32);` |
| [Trait 特征] | 特征 | 一个可以被共享的行为,只要实现了特征,你就能使用该行为 |
| [T: Trait] | 特征约束 | 还可以有多重约束,`T: Trait1 + Trait2`<br>另见:[where 约束] |
| [Trait Object] | 特征对象 | 特征对象指向实现了 `Trait` 特征的类型的实例,可以在运行时通过特征对象找到具体调用的类型方法 |
| `type` 1. [关联类型] 2. [默认泛型类型参数] | | 1. `type Item;`<br>`Self` 用来指代当前调用者的具体类型,那么 `Self::em` 就用来指代该类型实现中定义的 `Item` 类型<br>2. `type Output = Struct;`<br>指定一个默认值,返回一个关联类型 `Output` |
| [特征定义中的特征约束] | 特征 | 用来说明一个特征需要实现另一个特征 |
| | KWT | |
[tuple 元组]: https://course.rs/basic/compound-type/tuple.html#元组
[tuple struct]: https://course.rs/basic/compound-type/struct.html?search=#元组结构体tuple-struct
[tuple struct]: https://course.rs/basic/compound-type/struct.html#元组结构体tuple-struct
[trait 特征]: https://course.rs/basic/trait/trait.html#定义特征
[t: trait]: https://course.rs/basic/trait/trait.html#特征约束trait-bound
[trait object]: https://course.rs/basic/trait/trait-object.html#特征对象定义
[关联类型]: https://course.rs/basic/trait/advance-trait.html#关联类型
[默认泛型类型参数]: https://course.rs/basic/trait/advance-trait.html#默认泛型类型参数
[特征定义中的特征约束]: https://course.rs/basic/trait/advance-trait.html#特征定义中的特征约束
[back](#head)
@ -318,36 +354,38 @@
| 名称 | 关键字 | 简介 |
| ------------------ | ---------- | ------------------------------------------- |
| [Unit-like Struct] | 单元结构体 | 没有任何字段和属性<br>`struct AlwaysEqual;` |
| U | KWU | UIntroduction |
| | KWU | |
[unit-like struct]: https://course.rs/basic/compound-type/struct.html?search=#单元结构体unit-like-struct
[unit-like struct]: https://course.rs/basic/compound-type/struct.html#单元结构体unit-like-struct
[back](#head)
## V
| 名称 | 关键字 | 简介 |
| ---- | ------ | ------------- |
| V | KWV | VIntroduction |
| 名称 | 关键字 | 简介 |
| ---- | ------ | ---- |
| | KWV | |
[back](#head)
## W
| 名称 | 关键字 | 简介 |
| ------------ | -------- | ------------------------------------------------------ |
| [while 循环] | 循环控制 | 当条件为 `true` 时,继续循环,条件为 `false`,跳出循环 |
| W | KWW | WIntroduction |
| 名称 | 关键字 | 简介 |
| ------------ | -------- | ----------------------------------------------------------------- |
| [while 循环] | 循环控制 | 当条件为 `true` 时,继续循环,条件为 `false`,跳出循环 |
| [where 约束] | 特征约束 | 当特征约束变多时,函数签名会很复杂,可以用 `where` 做形式上的改进 |
| | KWW | |
[while 循环]: https://course.rs/basic/flow-control.html#while-循环
[where 约束]: https://course.rs/basic/trait/trait.html#where-约束
[back](#head)
## X
| 名称 | 关键字 | 简介 |
| ---- | ------ | ------------- |
| X | KWX | XIntroduction |
| 名称 | 关键字 | 简介 |
| ---- | ------ | ---- |
| | KWX | |
[back](#head)
@ -356,7 +394,7 @@
| 名称 | 关键字 | 简介 |
| ------ | ------ | ---------------------------------------------------- |
| [语句] | | 完成一个操作,结尾有 `;` ,无返回值,如 `let x = 9;` |
| Y | KWY | YIntroduction |
| | KWY | |
[语句]: https://course.rs/basic/base-type/statement-expression.html#语句
@ -368,7 +406,7 @@
| ------------ | -------- | ---------------------------------------------------------------------------------------------------------------- |
| [整数] | 数值类型 | 有符号整数,`i8``i16``i32``i64``i128``isize`<br>无符号整数,`u8``u16``u32``u64``u128``usize` |
| [整形字面量] | 进制书写 | 十进制 `98_222`<br>十六进制 `0xff`<br>八进制 `0o77`<br>二进制 `0b1111_0000`<br>字节(仅限于`u8`) `b'A'` |
| Z | KWZ | ZIntroduction |
| | KWZ | |
[整数]: https://course.rs/basic/base-type/numbers.html#整数类型
[整形字面量]: https://course.rs/basic/base-type/numbers.html#整数类型
@ -377,9 +415,9 @@
## Cargo
| 名称 | 关键字 | 简介 |
| ----- | ------ | -------------- |
| Cargo | KWCG | CGIntroduction |
| 名称 | 关键字 | 简介 |
| ----- | ------ | ---- |
| Cargo | KWCG | |
[back](#head)

@ -18,36 +18,36 @@
## 日常开发常用Rust库
### Web/HTTP
* HTTP客户端
* [reqwest](https://github.com/seanmonstar/reqwest) 一个简单又强大的HTTP客户端`reqwest`是目前使用最多的HTTP库
* [reqwest](https://github.com/seanmonstar/reqwest) 一个简单又强大的HTTP客户端`reqwest`是目前使用最多的HTTP库
* Web框架
* [axum](https://github.com/tokio-rs/axum) 基于Tokio和Hyper打造模块化设计较好目前口碑很好值得使用Ergonomic and modular web framework built with Tokio, Tower, and Hyper
* [Rocket](https://github.com/SergioBenitez/Rocket) 功能强大API简单的Web框架但是主要开发者目前因为个人原因无法进行后续开发未来存在不确定性
* [actix-web](https://github.com/actix/actix-web) 性能极高的Web框架就是团队内部有些问题未来存在一定的不确定性
* [axum](https://github.com/tokio-rs/axum) 基于Tokio和Hyper打造模块化设计较好目前口碑很好值得使用Ergonomic and modular web framework built with Tokio, Tower, and Hyper
* [Rocket](https://github.com/SergioBenitez/Rocket) 功能强大API简单的Web框架但是主要开发者目前因为个人原因无法进行后续开发未来存在不确定性
* [actix-web](https://github.com/actix/actix-web) 性能极高的Web框架就是团队内部有些问题未来存在一定的不确定性
* 总体来说上述三个web框架都有很深的用户基础其实都可以选用如果让我推荐顺序如下: `axum` > `Rocket` > `actix-web`。 不过如果你不需要多么完善的web功能只需要一个性能极高的http库那么`actix-web`是非常好的选择,它的性能非常非常非常高!
### 日志监控
* 日志
[[crates.io](https://crates.io/keywords/log)] [[github](https://github.com/search?q=rust+log)]
* [tokio-rs/tracing](https://github.com/tokio-rs/tracing) 强大的日志框架同时还支持OpenTelemetry格式无缝打通未来的监控
* [rust-lang/log](https://github.com/rust-lang/log) 官方日志库事实上的API标准, 但是三方库未必遵循
* [estk/log4rs](https://github.com/estk/log4rs) 模仿JAVA `logback`和`log4j`实现的日志库, 可配置性较强
* 在其它文章中也许会推荐slog但是我们不推荐一个是因为近半年未更新一个是`slog`自己也推荐使用`tracing`。
* [tokio-rs/tracing](https://github.com/tokio-rs/tracing) 强大的日志框架同时还支持OpenTelemetry格式无缝打通未来的监控
* [rust-lang/log](https://github.com/rust-lang/log) 官方日志库事实上的API标准, 但是三方库未必遵循
* [estk/log4rs](https://github.com/estk/log4rs) 模仿JAVA `logback`和`log4j`实现的日志库, 可配置性较强
* 在其它文章中,也许会推荐`slog`,但是我们不推荐,一个是因为近半年未更新,一个是`slog`自己也推荐使用`tracing`。
* 监控
* [OpenTelemetry](https://github.com/open-telemetry/opentelemetry-rust) `OpenTelemetry`是现在非常火的可观测性解决方案提供了协议、API、SDK等核心工具用于收集监控数据最后将这些metrics/logs/traces数据写入到`prometheus`, `jaeger`等监控平台中。最主要是,它后台很硬,后面有各大公司作为背书,未来非常看好!
* [vectordotdev/vector](https://github.com/vectordotdev/vector) 一个性能很高的数据采集agent采集本地的日志、监控等数据发送到远程的kafka、jaeger等数据下沉端它最大的优点就是能从多种数据源(包括Opentelemetry)收集数据,然后推送到多个数据处理或者存储等下沉端。
* [OpenTelemetry](https://github.com/open-telemetry/opentelemetry-rust) 是现在非常火的可观测性解决方案提供了协议、API、SDK等核心工具用于收集监控数据最后将这些metrics/logs/traces数据写入到`prometheus`, `jaeger`等监控平台中。最主要是,它后台很硬,后面有各大公司作为背书,未来非常看好!
* [vectordotdev/vector](https://github.com/vectordotdev/vector) 一个性能很高的数据采集agent采集本地的日志、监控等数据发送到远程的kafka、jaeger等数据下沉端它最大的优点就是能从多种数据源(包括Opentelemetry)收集数据,然后推送到多个数据处理或者存储等下沉端。
### SQL客户端
* 通用
* [launchbadge/sqlx](https://github.com/launchbadge/sqlx) 异步实现、高性能、纯Rust代码的SQL库支持`PostgreSQL`, `MySQL`, `SQLite`,和 `MSSQL`.
* ORM
* [rbatis/rbatis](https://github.com/rbatis/rbatis) 国内团队开发的ORM异步、性能高、简单易上手
* [diesel-rs/diesel](https://github.com/diesel-rs/diesel) 安全、扩展性强的Rust ORM库支持`MySQL`、`PostgreSQL`、`SQLLite`
* [rbatis/rbatis](https://github.com/rbatis/rbatis) 国内团队开发的ORM异步、性能高、简单易上手
* [diesel-rs/diesel](https://github.com/diesel-rs/diesel) 安全、扩展性强的Rust ORM库支持`MySQL`、`PostgreSQL`、`SQLLite`
* MySQL
* [blackbeam/rust-mysql-simple](https://github.com/blackbeam/rust-mysql-simple) 纯Rust实现的MySQL驱动,提供连接池
* [blackbeam/mysql_async](https://github.com/blackbeam/mysql_async) 基于Tokio实现的异步MySQL驱动
* [blackbeam/rust-mysql-simple](https://github.com/blackbeam/rust-mysql-simple) 纯Rust实现的MySQL驱动,提供连接池
* [blackbeam/mysql_async](https://github.com/blackbeam/mysql_async) 基于Tokio实现的异步MySQL驱动
* 上面两个都是一个团队出品前者文档更全、star更多建议使用前者
* PostgreSQL
@ -63,7 +63,7 @@
* Canssandra
* [krojew/cdrs-tokio](https://github.com/krojew/cdrs-tokio) [[cdrs-tokio](https://crates.io/crates/cdrs-tokio)] 生产可用的Cassandra客户端异步、纯Rust实现就是个人项目 + star较少未来不确定会不会不维护
* [scylla-rust-driver](https://github.com/scylladb/scylla-rust-driver) ScyllaDB提供的官方库支持cql协议由于背靠大山未来非常可期
* [scylla-rust-driver](https://github.com/scylladb/scylla-rust-driver) ScyllaDB提供的官方库支持cql协议由于背靠大山未来非常可期
* MongoDB
* [mongodb/mongo-rust-driver](https://github.com/mongodb/mongo-rust-driver) 官方MongoDB客户端闭着眼睛选就对了
@ -75,8 +75,8 @@
#### 消息队列
* Kafka
* [fede1024/rust-rdkafka](https://github.com/fede1024/rust-rdkafka) Rust Kafka客户端基于C版本的Kafka库[librdkafka]实现,文档较全、功能较为全面
* [kafka-rust/kafka-rust](https://github.com/kafka-rust/kafka-rust) 相比上一个库它算是纯Rust实现文档还行支持Kafka0.8.2及以后的版本但是对于部分0.9版本的特性还不支持。同时有一个问题:最初的作者不维护了,转给了现在的作者,但是感觉好像也不是很活跃
* [fede1024/rust-rdkafka](https://github.com/fede1024/rust-rdkafka) Rust Kafka客户端基于C版本的Kafka库[librdkafka]实现,文档较全、功能较为全面
* [kafka-rust/kafka-rust](https://github.com/kafka-rust/kafka-rust) 相比上一个库它算是纯Rust实现文档还行支持Kafka0.8.2及以后的版本但是对于部分0.9版本的特性还不支持。同时有一个问题:最初的作者不维护了,转给了现在的作者,但是感觉好像也不是很活跃
* Nats
* [nats-io/nats.rs](https://github.com/nats-io/nats.rs) Nats官方提供的客户端
@ -84,7 +84,7 @@
### 网络、通信协议
* WebSocket
* [snapview/tokio-tungstenite](https://github.com/snapview/tokio-tungstenite) 更适合Web应用使用的生产级Websocket库它是异步非阻塞的基于下面的`tungstenite-rs`库和tokio实现
* [rust-websocket](https://github.com/websockets-rs/rust-websocket) 老牌Websocket库提供了客户端和服务器端实现但是。。。很久没更新了
* [rust-websocket](https://github.com/websockets-rs/rust-websocket) 老牌Websocket库提供了客户端和服务器端实现但是。。。很久没更新了
* [snapview/tungstenite-rs](https://github.com/snapview/tungstenite-rs) 轻量级的Websocket流实现该库更偏底层例如你可以用来构建其它网络库
* gRPC
@ -97,16 +97,16 @@
* [quinn-rs/quinn](https://github.com/quinn-rs/quinn) 提供异步API调用纯Rust实现同时提供了几个有用的网络库
* MQTT
* [bytebeamio/rumqtt](https://github.com/bytebeamio/rumqtt) MQTT3.1.1/5协议库同时实现了客户端与服务器端broker
* [ntex-rs/ntex-mqtt](https://github.com/ntex-rs/ntex-mqtt) 客户端与服务端框架支持MQTT3.1.1与5协议
* [eclipse/paho.mqtt.rust](https://github.com/eclipse/paho.mqtt.rust) 老牌MQTT框架对MQTT支持较全, 其它各语言的实现也有
* [bytebeamio/rumqtt](https://github.com/bytebeamio/rumqtt) MQTT3.1.1/5协议库同时实现了客户端与服务器端broker
* [ntex-rs/ntex-mqtt](https://github.com/ntex-rs/ntex-mqtt) 客户端与服务端框架支持MQTT3.1.1与5协议
* [eclipse/paho.mqtt.rust](https://github.com/eclipse/paho.mqtt.rust) 老牌MQTT框架对MQTT支持较全, 其它各语言的实现也有
### 异步网络编程
* [tokio-rs/tokio](https://github.com/tokio-rs/tokio) 最火的异步网络库除了复杂上手难度高一些外没有其它大的问题。同时tokio团队提供了多个非常优秀的Rust库整个生态欣欣向荣用户认可度很高
* [async-std](https://async.rs/) 跟标准库API很像的异步网络库相对简单易用但是貌似开发有些停滞还有就是功能上不够完善。但是对于普通用户来说这个库非常值得一试它在功能和简单易用上取得了很好的平衡
* [actix](https://github.com/actix/actix) 基于Actor模型的异步网络库但这个库的开发貌似已经停滞他们团队一直在专注于`actix-web`的开发
* [mio](https://github.com/tokio-rs/mio) 严格来说MIO与之前三个不是同一个用途的MIO = Meta IO是一个底层IO库往往用于构建其它网络库当然如果你对应用网络性能有非常极限的要求 可以考虑它,因为它的层次比较低,所带来的抽象负担小,所以性能损耗小
* [mio](https://github.com/tokio-rs/mio) 严格来说MIO与之前三个不是同一个用途的MIO = Meta IO是一个底层IO库往往用于构建其它网络库当然如果你对应用网络性能有非常极限的要求可以考虑它因为它的层次比较低所带来的抽象负担小所以性能损耗小
* 如果你要开发生产级别的项目,我推荐使用`tokio`,稳定可靠,功能丰富,控制粒度细;自己的学习项目或者没有那么严肃的开源项目,我推荐`async-std`简单好用值得学习当你确切知道需要Actor网络模型时就用`actix`
@ -116,22 +116,22 @@
* [elastic/elasticsearch](https://github.com/elastic/elasticsearch-rs) 官方es客户端目前第三方的基本都处于停滞状态所以不管好坏用呗
* Rust搜索引擎
* [Tantivy](https://github.com/quickwit-inc/tantivy) Tantivy是Rust实现的本地搜索库功能对标`lucene`如果你不需要分布式那么引入tantivy作为自己本地Rust服务的一个搜索是相当不错的选择该库作者一直很活跃而且最近还创立了搜索引擎公司感觉大有作为. 该库的优点在于纯Rust实现性能高(lucene的2-3倍),资源占用低(对比java自然不是一个数量级),社区活跃。
* [Tantivy](https://github.com/quickwit-inc/tantivy) Tantivy是Rust实现的本地搜索库功能对标`lucene`如果你不需要分布式那么引入tantivy作为自己本地Rust服务的一个搜索是相当不错的选择该库作者一直很活跃而且最近还创立了搜索引擎公司感觉大有作为该库的优点在于纯Rust实现性能高(lucene的2-3倍),资源占用低(对比java自然不是一个数量级),社区活跃。
* Rust搜索平台
* [quickwit](https://github.com/quickwit-inc/quickwit) 对标ElasticSearch一个通用目的的分布式搜索平台目前还在起步阶段(0.2版本),未来非常可期,目前还不建议使用
* [MeiliSearch](https://github.com/meilisearch/MeiliSearch) 虽然也是一个搜索平台,但是并不是通用目的的,`MeiliSearch`目标是为终端用户提供边输入边提示的即刻搜索功能因此是一个轻量级搜索平台不适用于数据量大时的搜索目的。总之如果你需要在网页端或者APP为用户提供一个搜索条然后支持输入容错、前缀搜索时就可以使用它。
*
### 代码Debug
* GDB
* [gdbgui](https://github.com/cs01/gdbgui) 提供浏览器支持的gdb debug工具支持CC++Rust和Go.
* [gdbgui](https://github.com/cs01/gdbgui) 提供浏览器支持的gdb debug工具支持CC++Rust和Go.
* LLDB
* [CodeLLDB](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb) 专门为VSCode设计的LLDB Debug扩展
* [CodeLLDB](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb) 专门为VSCode设计的LLDB Debug扩展
### 性能优化
* [bheisler/criterion.rs](https://github.com/bheisler/criterion.rs) 比官方提供的benchmark库更好目前已经成为事实上标准的性能测试工具
* [Bytehound](https://github.com/koute/bytehound) Linux下的内存分析工具可以用来分析内存泄漏、内存分配、调用栈追踪甚至它还有一个浏览器UI! 懂的人都懂性能测试工具的UI服务是多么稀缺和珍贵
* [Bytehound](https://github.com/koute/bytehound) Linux下的内存分析工具可以用来分析内存泄漏、内存分配、调用栈追踪甚至它还有一个浏览器UI懂的人都懂性能测试工具的UI服务是多么稀缺和珍贵
* [llogiq/flame](https://github.com/llogiq/flame) 专为Rust打造的火焰图分析工具可以告诉你程序在哪些代码上花费的时间过多非常适合用于代码性能瓶颈的分析。与`perf`不同,`flame`库允许你自己定义想要测试的代码片段,只需要在代码前后加上相应的指令即可,非常好用
* [sharkdp/hyperfine](https://github.com/sharkdp/hyperfine) 一个命令行benchmark工具支持任意shell命令支持缓存清除、预热、多次运行统计分析等尽量保证结果的准确性
@ -142,7 +142,7 @@
* [BurntSushi/rust-csv](https://github.com/BurntSushi/rust-csv) 高性能CSV读写库支持[Serde](https://github.com/serde-rs/serde)
* JSON
* [serde-rs/json](https://github.com/serde-rs/json) 快到上天的JSON库也是Rust事实上的标准JSON库你也可以使用它的大哥[serde](https://github.com/serde-rs/serde),一个更通用的序列化/反序列化库
* [serde-rs/json](https://github.com/serde-rs/json) 快到上天的JSON库也是Rust事实上的标准JSON库你也可以使用它的大哥[Serde](https://github.com/serde-rs/serde),一个更通用的序列化/反序列化库
* MsgPack
* [3Hren/msgpack-rust](https://github.com/3Hren/msgpack-rust) 纯Rust实现的MessagePack编解码协议

@ -1,81 +1,116 @@
# Rust 语言周刊」 第 10 期 · 2022-04-29
# Rust语言周刊
Rust语言周刊精选全世界过去一周的优秀文章、新闻、开源项目和语言动态。
本周刊由 RustCn 社区倾情打造,其中, `[Zh]` 标识的中文资料由 Rust 翻译计划提供,并且原始的 Markdown 文档已[全部开源](https://github.com/rustlang-cn/rustt),欢迎大家阅读和订阅。
本周刊由 RustCn 倾情打造,其中, `[Zh]` 标识的中文资料由 Rust 翻译计划提供,并且原始的 Markdown 文档已[全部开源](https://github.com/rustlang-cn/rustt),欢迎大家阅读和订阅。
> RustCnhttps://hirust.cn, 公众号: Rust语言中文网
<img src="https://pica.zhimg.com/80/v2-03ba9143032c8bcef9fd38b195dfaa21_1440w.png">
<h5 align="center">题图: Robyn</h5>
# 「Rust 语言周刊」 第 11 期 · 2022-05-07
#### Rust新闻
<img src="https://pic2.zhimg.com/80/v2-6243e39368f24d4193564a701942413f_1440w.png">
<h5 align="center">题图: 可视化 Rust 数据类型的内存布局</h5>
#### 本期明星
1、[Zh] [可视化 Rust 数据类型的内存布局](https://github.com/rustlang-cn/Rustt/blob/main/Articles/%5B2022-05-04%5D%20可视化%20Rust%20各数据类型的内存布局.md)
了解 Rust 中每个数据类型的内存布局有助于锻炼我们的编程直觉,可以提前规避一些编译错误和性能问题。
原文是以视频形式呈现,译文是由 Rustt 翻译组的明星译者 trdthg (third thing) 倾情翻译,内容巨多、工作量巨大,如果大家喜欢,在[这里](https://github.com/trdthg)给他点个赞吧 :D
1、[Rust 库团队的愿景](https://blog.rust-lang.org/inside-rust/2022/04/20/libs-aspirations.html)
最近Rust 语言发布了 [2024 年展望](https://zhuanlan.zhihu.com/p/490221490),编译器团队也发布了 [2022年 野望](https://blog.rust-lang.org/inside-rust/2022/02/22/compiler-team-ambitions-2022.html),现在库团队也不甘落后,为我们带了了未来的库规划和生态发展愿景。
#### 开源项目
1、[shuttle: 使用 Cargo 部署你的 Rust 应用](https://www.shuttle.rs)
说实话,这个库真的很酷很 rusty它完成了从源代码到云部署的全过程覆盖支持通过派生特征的方式去自定义你的部署流程甚至还提供了短域名服务
哦对了,我特别喜欢 shuttle 的 slogan
1、[Robyn: 一个全新的 Python Web 框架](https://www.sanskar.me/hello_robyn.html)
> **Let's make Rust the next language of cloud-native**
>
> We love you Go, but Rust is just better.
大家会不会以为自己走错片场了?:D 其实没有,因为这个框架是基于 Rust 运行时实现的,在提供了高性能、高吞吐的同时,又能使用 Python 来愉快地写逻辑代码。
你们喜欢不?😆
2、[Redox发布0.7.0: 一个完全用 Rust 编写,专注于稳定性和安全性的全新微内核操作系统](https://www.redox-os.org/news/release-0.7.0/)
|Total Time(seconds) | Slowest(seconds) | Fastest(seconds)| Average(seconds) |Requests/sec |
| --- | --- | --- | --- | --- |
| Flask(Gunicorn) | 5.5254 | 0.0784 | 0.0028 | 0.0275 | 1809.8082
|FastAPI(API) | 4.1314 | 0.0733 | 0.0027 | 0.0206 | 2420.4851
|Django(Gunicorn) | 13.5070 | 0.3635 | 0.0249 | 0.0674 | 740.3558
|Robyn(1 process and 1 worker) | 1.8324 | 0.0269 | 0.0024 | 0.0091 | 5457.2339
|Robyn(5 processes and 5 workers) | 1.5592 | 0.0211 | 0.0017 | 0.0078 | 6413.6480
Redox 不是一个新项目,已开发多年,但仍达不到成熟可用的状态,毕竟操作系统不是一个小工程。
2、[Gitoxide: 一个使用 Rust 实现的 Git 命令](https://github.com/Byron/gitoxide/discussions/398)
不过这次的新版本改动还是挺大的对硬件扩展的支持、改进的文件系统、重写的引导程序、微内核的更新甚至它还改进了rustc 和 reibc(基于 Rust 的 C 库)。
它不仅拥有丰富的仓库信息展示,还能在 1 秒内克隆下来 linux 内核代码,它的作者还是一个生活在西安的外国人,它...名字好难记。
> 求大佬告知:国内在做操作系统的厂商是否有在跟进这个项目,基于它来做一个国产操作系统,不知道有没有搞头
3、[czkawka: 从计算机中移除无需的文件](https://github.com/qarmin/czkawka)
3、[重生之路之 Plotters ](https://github.com/plotters-rs/plotters)
Plotters 是一个非常棒的纯 Rust 编写的绘图库( charts ),除了支持位图、向量图等传统方式外,还支持 WebAssembly。
但..这个库之前很长一段时间内都没怎么维护,而且还是个人项目,其它贡献者只能望洋兴叹,作为一门有志于 GUI、前端领域的语言这个库还是非常重要的。
好在,现在作者宣布了自己已经归来,并重新建立了一个组织用于维护该项目。
<img src="https://pic2.zhimg.com/80/v2-494d0f57300cb3c7950b19b838430dbf_1440w.jpeg" />
大家不要问我项目名该怎么读,我也不会。但是这个项目还是挺有用的,可以在你的计算机中找出重复的文件、空目录、相似的图片等等。
#### 精选文章
1、[Zh] [基于 RocksDB 使用 Rust 构建关系型数据库](https://github.com/rustlang-cn/Rustt/blob/main/Articles/%5B2022-04-15%5D%20基于RocksDB使用Rust构建关系型数据库.md)
1、[Zh] [Rust类型系统图灵完备的证明](https://github.com/rustlang-cn/Rustt/blob/main/Articles/%5B2022-05-04%5D%20Rust类型系统图灵完备的证明.md)
一门编程语言要进入科研等严肃领域,必须要经过九九之关的检验,其中图灵完备的证明就是其中一环。本文作者通过实现 Smallfuck 的方式(一门已知的图灵完备语言),证明了 Rust 的类型系统是图灵完备的。
2、 [Zh] [使用 Rust 和 WebAssembly 在 48 小时内制作游戏](https://github.com/rustlang-cn/Rustt/blob/main/Articles/%5B2022-04-27%5D%20使用%20Rust%20和%20WebAssembly%20在%2048%20小时内制作游戏.md)
[Ludum Dare] 是一个 48 小时个人游戏开发挑战赛,作者之前已经使用 Unity 参加过几次了,这次,他决定尝试点不一样的。
3、[Zh] [半小时快速了解 Rust](https://github.com/rustlang-cn/Rustt/blob/main/Articles/%5B2022-04-28%5D%20半小时快速了解%20Rust.md)
21天7天3天都弱爆了好吗这里只要半个小时
4、[GAT的美好未来](https://jackh726.github.io/rust/2022/05/04/a-shiny-future-with-gats.html)
GAT 是 Generic Associated Types (泛型关联类型) 的简写,大家可以在[这里](https://blog.rust-lang.org/2021/08/03/GATs-stabilization-push.html)对其进行深入了解。
GAT 计划是在1年多之前就开始了本身计划在去年 10 月稳定化的,但是其中遇到了不少问题,导致了计划的延期,然后就是 12 月、2月( 这种感觉好熟悉:P )。
现在,作者终于可以骄傲的写出这篇文章,来告诉我们 GAT 到底可以用来做什么,质量很高,值得一看!
> 关于 GAT 还有另一篇文章值得一读:[生命周期 GAT 的更好替代品](https://sabrinajewson.org/blog/the-better-alternative-to-lifetime-gats)
5、[C++ & Rust: 泛型和特性化](https://www.tangramvision.com/blog/c-rust-generics-and-specialization)
现在很多新的数据库底层都是基于 RocksDB 来实现的,作者的 `rrrdb` 亦是如此,从名称也能看出,这个项目不是一个很正式的关系型数据库,但是不妨碍我们去了解下作者的一些构思和实现。
一周一次、喜闻乐见的 C++ Pk Rust 环节又来了,作者所在的公司原本是做 C++ 的,但是在遇到 Rust 后,变心了,甚至还加入了 Rust 基金会,一起来欣赏下他们的一些看法吧
2、[Zh] [使用 Tokio 处理 CPU 密集型任务](https://github.com/rustlang-cn/Rustt/blob/main/Articles/%5B2022-04-20%5D%20使用%20Tokio%20处理%20CPU%20密集型任务.md)
众所周知tokio 是一个异步 IO 库,众所周知知,异步 IO 特别适合网络编程,并不是很适合 CPU 密集的场景,且看作者如何化腐朽为神奇。
6、[这些年 Rust 编译器帮你捕获的 Bug 们](https://kerkour.com/bugs-rust-compiler-helps-prevent)
3、[假设 Rust 目前还是一门相当不完美的语言,我们该怎么改进它?](https://kerkour.com/what-a-better-rust-would-look-like)
在过去几十年内,随着程序员水平的越来越高,我们终于证明了自己 —— 没办法写出 Bug Free 的软件。因此新编程语言的编译器越来越强大也越来越复杂Rust 就是其中的翘楚。
最近,又双叒叕出了一门新的编程语言:[Hare](https://harelang.org),语法看上去很像 Rust作者不禁开始思考人们为啥去创建一门像是 Rust 的新语言,答案可能就藏在文章的标题中。
7、[自引用结构体和其替代品](https://swatinem.de/blog/self-reference-alternatives/)
4、[间接所有权、浅借用和自引用数据结构](https://yoyo-code.com/indirect-ownership-and-self-borrow/)
文章讲解了该如何更好的理解和使用自引用结构体,以及在一些场景下,该如何使用其它方式来替代自引用结构题。
什么?有读者震惊了,为啥这几个概念我都没有听说过?不要慌,其实就是一篇讲解自引用数据结构的文章,例如下面这个结构体:
```rust
struct ParsedFile {
contents: Vec<u8>,
// words中包含的项引用了 `contents` 中的数据
words: Vec<&'self:contents:indirect [u8]>
}
```
5、[Rust 中的特征和依赖注入](https://jmmv.dev/2022/04/rust-traits-and-dependency-injection.html)
在现代化编程中,依赖注入不说是 superstar至少也是一颗 star它可以大幅简化模块化编程和代码可测试性的难度。本文将从特征出发来看看在 Rust 中该如何实现 DI(dependency injection)。
6、[Rust 中的原生标识符](https://inspektor.cloud/blog/raw-identifier-in-rust/)
不要被标题误导,这篇文章简而言之,就是教大家如果使用 Rust 的预留关键字作为自己的变量或字段名。
7、[AsRef 中藏有的魔法](https://swatinem.de/blog/magic-asref/)
## 往期回顾
一般的开发场景中,不太用得到 AsRef但是如果你和作者一样从事词法分析相关的开发(或其它类型的数据场景),就值得深入了解下了
目前所有的周刊都按照 `年/月/日期` 的方式归纳在 [docs](./docs) 目录下,大家可以按需查看。
8、[在四周内构建一个无服务架构平台](https://www.shuttle.rs/blog/2022/04/22/dev-log-0)
- [第 10 期](./docs/2022/5月/07.md)
- [第 9 期](./docs/2022/4月/24.md)
- [第 8 期](./docs/2022/4月/15.md)
- [第 7 期](./docs/2022/4月/08.md)
- [第 6 期](./docs/2022/4月/02.md)
- [第 5 期](./docs/2022/3月/25.md)
- [第 4 期](./docs/2022/3月/18.md)
- [第 3 期](./docs/2022/3月/11.md)
- [第 2 期](./docs/2022/3月/04.md)
- [第 1 期](./docs/2022/2月/28.md)
假如你发现了一个潜在的商机,想要给投资人证明这一点,时间很紧迫,只有四周,你会怎么办?
## 怀揣劲爆消息或优质内容?
欢迎提交 `issue``PR`,我们欢迎一切有价值的内容,并且你提供的每条消息都将标注上你的 github 用户名和链接。

Loading…
Cancel
Save