Merge branch 'sunface:main' into main

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

@ -136,7 +136,7 @@ error[E0015]: calls in statics are limited to constant functions, tuple structs
#### lazy_static
[`lazy_static`](https://github.com/rust-lang-nursery/lazy-static.rs)是社区提供的非常强大的宏,用于懒初始化静态变量,之前的静态变量都是在编译初始化的,因此无法使用函数调用进行赋值,而`lazy_static`允许我们在运行期初始化静态变量!
[`lazy_static`](https://github.com/rust-lang-nursery/lazy-static.rs)是社区提供的非常强大的宏,用于懒初始化静态变量,之前的静态变量都是在编译初始化的,因此无法使用函数调用进行赋值,而`lazy_static`允许我们在运行期初始化静态变量!
```rust
use std::sync::Mutex;

@ -12,7 +12,10 @@ fn add_with_extra(x: i32, y: i32) -> i32 {
语句会执行一些操作但是不会返回一个值,而表达式会在求值后返回一个值,因此在上述函数体的三行代码中,前两行是语句,最后一行是表达式。
对于 Rust 语言而言,**这种基于语句和表达式的方式是非常重要的,你需要能明确的区分这两个概念**, 但是对于很多其它语言而言,这两个往往无需区分。基于表达式是函数式语言的重要特征,**表达式总要返回值**。
对于 Rust 语言而言,**这种基于语句statement和表达式expression的方式是非常重要的你需要能明确的区分这两个概念**, 但是对于很多其它语言而言,这两个往往无需区分。基于表达式是函数式语言的重要特征,**表达式总要返回值**。
其实,在此之前,我们已经多次使用过语句和表达式。
@ -97,9 +100,14 @@ fn main() {
fn ret_unit_type() {
let x = 1;
// if 语句块也是一个表达式,因此可以用于赋值,也可以直接返回
if (x > 1) {
}
// 类似三元运算符在Rust里我们可以这样写
let y = if x % 2 == 1 {
"odd"
} else {
"even"
};
// 或者写成一行
let z = if x % 2 == 1 { "odd" } else { "even" };
}
```

@ -24,7 +24,7 @@ my_gems.insert("河边捡的误以为是宝石的破石头", 18);
很简单对吧?跟其它语言没有区别,聪明的同学甚至能够猜到该 `HashMap` 的类型:`HashMap<&str,i32>`。
但是还有一点,你可能没有注意,那就是使用 `HashMap` 需要手动通过 `use ...` 从标准库中引入到我们当前的作用域中来,仔细回忆下,之前使用另外两个集合类型 `String``Vec` 时,我们是否有手动引用过?答案是 `No`,因为 `HashMap` 并没有包含在 Rust 的 [`prelude`](https://course.rs/appendix/prelude.html) 中Rust 为了简化用户使用,提前将最常用的类型自动引入到作用域中)。
但是还有一点,你可能没有注意,那就是使用 `HashMap` 需要手动通过 `use ...` 从标准库中引入到我们当前的作用域中来,仔细回忆下,之前使用另外两个集合类型 `String``Vec` 时,我们是否有手动引用过?答案是 **No**,因为 `HashMap` 并没有包含在 Rust 的 [`prelude`](https://course.rs/appendix/prelude.html) 中Rust 为了简化用户使用,提前将最常用的类型自动引入到作用域中)。
所有的集合类型都是动态的,意味着它们没有固定的内存大小,因此它们底层的数据都存储在内存堆上,然后通过一个存储在栈中的引用类型来访问。同时,跟其它集合类型一致,`HashMap` 也是内聚性的,即所有的 `K` 必须拥有同样的类型,`V` 也是如此。
@ -36,7 +36,7 @@ my_gems.insert("河边捡的误以为是宝石的破石头", 18);
例如考虑一个场景,有一张表格中记录了足球联赛中各队伍名称和积分的信息,这张表如果被导入到 Rust 项目中,一个合理的数据结构是 `Vec<(String, u32)>` 类型,该数组中的元素是一个个元组,该数据结构跟表格数据非常契合:表格中的数据都是逐行存储,每一个行都存有一个 `(队伍名称, 积分)` 的信息。
但是在很多时候,又需要通过队伍名称来查询对应的积分,此时动态数组就不适用了,因此可以用 `HashMap` 来保存相关的**队伍名称 -> 积分**映射关系。 理想很骨感,现实很丰满,如何将 `Vec<(String, u32)>` 中的数据快速写入到 `HashMap<String, u32>` 中?
但是在很多时候,又需要通过队伍名称来查询对应的积分,此时动态数组就不适用了,因此可以用 `HashMap` 来保存相关的**队伍名称 -> 积分**映射关系。 理想很丰满,现实很骨感,如何将 `Vec<(String, u32)>` 中的数据快速写入到 `HashMap<String, u32>` 中?
一个动动脚趾头就能想到的笨方法如下:
@ -79,7 +79,7 @@ fn main() {
}
```
代码很简单,`into_iter` 方法将列表转为迭代器,接着通过 `collect` 进行收集,不过需要注意的是,`collect` 方法在内部实际上支持生成多种类型的目标集合,因我们需要通过类型标注 `HashMap<_,_>` 来告诉编译器:请帮我们收集为 `HashMap` 集合类型,具体的 `KV` 类型,麻烦编译器您老人家帮我们推导。
代码很简单,`into_iter` 方法将列表转为迭代器,接着通过 `collect` 进行收集,不过需要注意的是,`collect` 方法在内部实际上支持生成多种类型的目标集合,因我们需要通过类型标注 `HashMap<_,_>` 来告诉编译器:请帮我们收集为 `HashMap` 集合类型,具体的 `KV` 类型,麻烦编译器您老人家帮我们推导。
由此可见Rust 中的编译器时而小聪明,时而大聪明,不过好在,它大聪明的时候,会自家人知道自己事,总归会通知你一声:

@ -1,6 +1,6 @@
# 集合类型
在 Rust 标准库中有这样一批原住民,它们天生贵族,当你看到的一瞬间,就能爱上它们,上面是我瞎编的,其实主要是离了它们不行,不信等会我介绍后,你放个狠话,非它们不用试试?
在 Rust 标准库中有这样一批原住民,它们天生贵族,当你看到的一瞬间,就能爱上它们,上面是我瞎编的,其实主要是离了它们不行,不信等会我介绍后,你放个狠话,偏不用它们试试?
集合在 Rust 中是一类比较特殊的类型,因为 Rust 中大多数数据类型都只能代表一个特定的值,但是集合却可以代表一大堆值。而且与语言级别的数组、字符串类型不同,标准库里的这些家伙是分配在堆上,因此都可以进行动态的增加和减少。

@ -10,7 +10,7 @@
在 Rust 中,有多种方式可以创建动态数组。
#### Vec::new
### Vec::new
使用 `Vec::new` 创建动态数组是最 rusty 的方式,它调用了 `Vec` 中的 `new` 关联函数:
@ -29,7 +29,7 @@ v.push(1);
> 如果预先知道要存储的元素个数,可以使用 `Vec::with_capacity(capacity)` 创建动态数组,这样可以避免因为插入大量新数据导致频繁的内存分配和拷贝,提升性能
#### vec![]
### vec![]
还可以使用宏 `vec!` 来创建数组,与 `Vec::new` 有所不同,前者能在创建同时给予初始化值:
@ -85,9 +85,9 @@ match v.get(2) {
和其它语言一样,集合类型的索引下标都是从 `0` 开始,`&v[2]` 表示借用 `v` 中的第三个元素,最终会获得该元素的引用。而 `v.get(2)` 也是访问第三个元素,但是有所不同的是,它返回了 `Option<&T>`,因此还需要额外的 `match` 来匹配解构出具体的值。
#### 下标索引与 `.get` 的区别
### 下标索引与 `.get` 的区别
这两种方式都能成功的读取到指定的数组元素,既然如此为什么会存在两种方法?何况 `.get` 还会增加使用复杂度,让我们通过示例说明:
这两种方式都能成功的读取到指定的数组元素,既然如此为什么会存在两种方法?何况 `.get` 还会增加使用复杂度,这就涉及到数组越界的问题了,让我们通过示例说明:
```rust
let v = vec![1, 2, 3, 4, 5];
@ -102,7 +102,7 @@ let does_not_exist = v.get(100);
既然有两个选择,肯定就有如何选择的问题,答案很简单,当你确保索引不会越界的时候,就用索引访问,否则用 `.get`。例如,访问第几个数组元素并不取决于我们,而是取决于用户的输入时,用 `.get` 会非常适合,天知道那些可爱的用户会输入一个什么样的数字进来!
##### 同时借用多个数组元素
## 同时借用多个数组元素
既然涉及到借用数组元素,那么很可能会遇到同时借用多个数组元素的情况,还记得在[所有权和借用](https://course.rs/basic/ownership/borrowing.html#借用规则总结)章节咱们讲过的借用规则嘛?如果记得,就来看看下面的代码 :)
@ -169,7 +169,7 @@ for i in &mut v {
## 存储不同类型的元素
在本节开头,有讲到数组的元素必类型相同,但是也提到了解决方案:那就是通过使用枚举类型和特征对象来实现不同类型元素的存储。先来看看通过枚举如何实现:
在本节开头,有讲到数组的元素必类型相同,但是也提到了解决方案:那就是通过使用枚举类型和特征对象来实现不同类型元素的存储。先来看看通过枚举如何实现:
```rust
#[derive(Debug)]
@ -227,9 +227,9 @@ fn main() {
}
```
比枚举实现要稍微复杂一些,我们为 `V4``V6` 都实现了特征 `IpAddr`,然后将它俩的实例用 `Box::new` 包裹后,存在了数组 `v` 中,需要注意的是,这里必需手动的指定类型:`Vec<Box<dyn IpAddr>>`,表示数组 `v` 存储的是特征 `IpAddr` 的对象,这样就实现了在数组中存储不同的类型。
比枚举实现要稍微复杂一些,我们为 `V4``V6` 都实现了特征 `IpAddr`,然后将它俩的实例用 `Box::new` 包裹后,存在了数组 `v` 中,需要注意的是,这里必须手动地指定类型:`Vec<Box<dyn IpAddr>>`,表示数组 `v` 存储的是特征 `IpAddr` 的对象,这样就实现了在数组中存储不同的类型。
在实际使用场景中,特征对象数组要比枚举数组常见很多,主要原因在于[特征对象](https://course.rs/basic/trait/trait-object.html)非常灵活,而编译器对枚举的限制较多,且无法动态增加类型。
在实际使用场景中,**特征对象数组要比枚举数组常见很多**,主要原因在于[特征对象](https://course.rs/basic/trait/trait-object.html)非常灵活,而编译器对枚举的限制较多,且无法动态增加类型。
最后,如果你想要了解 `Vector` 更多的用法,请参见本书的标准库解析章节:[`Vector`常用方法](https://course.rs/std/vector.html)

@ -64,7 +64,7 @@ let slice = &s[0..2];
let slice = &s[..2];
```
同样的,如果你的切片想要包含 `String` 的最后一个字节,则可以这样使用:
同样的,如果你的切片想要包含 `String` 的最后一个字节,则可以这样使用
```rust
let s = String::from("hello");
@ -86,7 +86,7 @@ let slice = &s[0..len];
let slice = &s[..];
```
> 在对字符串使用切片语法时需要格外小心,切片的索引必须落在字符之间的边界位置,也就是 UTF-8 字符的边界,例如中文在 UTF-8 中占用三个字节,下面的代码就会崩溃:
> 在对字符串使用切片语法时需要格外小心,切片的索引必须落在字符之间的边界位置,也就是 UTF-8 字符的边界,例如中文在 UTF-8 中占用三个字节,下面的代码就会崩溃:
>
> ```rust
> let s = "中国人";
@ -204,7 +204,7 @@ fn say_hello(s: &str) {
## 字符串索引
在其它语言中,使用索引的方式访问字符串的某个字符或者子串是很正常的行为,但是在 Rust 中就会报错:
在其它语言中,使用索引的方式访问字符串的某个字符或者子串是很正常的行为,但是在 Rust 中就会报错
```rust
let s1 = String::from("hello");
@ -493,11 +493,11 @@ fn main() {
string_clear = ""
```
#### 连接 (Catenate)
#### 连接 (Concatenate)
1、使用 `+` 或者 `+=` 连接字符串
使用 `+` 或者 `+=` 连接字符串要求右边的参数必须为字符串的切片引用Slice)类型。其实当调用 `+` 的操作符时,相当于调用了 `std::string` 标准库中的 [`add()`](https://doc.rust-lang.org/std/string/struct.String.html#method.add) 方法,这里 `add()` 方法的第二个参数是一个引用的类型。因此我们在使用 `+` 必须传递切片引用类型。不能直接传递 `String` 类型。**`+` 和 `+=` 都是返回一个新的字符串。所以变量声明可以不需要 `mut` 关键字修饰**。
使用 `+` 或者 `+=` 连接字符串要求右边的参数必须为字符串的切片引用Slice类型。其实当调用 `+` 的操作符时,相当于调用了 `std::string` 标准库中的 [`add()`](https://doc.rust-lang.org/std/string/struct.String.html#method.add) 方法,这里 `add()` 方法的第二个参数是一个引用的类型。因此我们在使用 `+` 必须传递切片引用类型。不能直接传递 `String` 类型。**`+` 和 `+=` 都是返回一个新的字符串。所以变量声明可以不需要 `mut` 关键字修饰**。
示例代码如下:
@ -607,7 +607,7 @@ fn main() {
}
```
当然,在某些情况下,可能你会希望保持字符串的原样,不要转义:
当然,在某些情况下,可能你会希望保持字符串的原样,不要转义
```rust
fn main() {
println!("{}", "hello \\x52\\x75\\x73\\x74");
@ -675,7 +675,7 @@ for b in "中国人".bytes() {
想要准确的从 UTF-8 字符串中获取子串是较为复杂的事情,例如想要从 `holla中国人नमस्ते` 这种变长的字符串中取出某一个子串,使用标准库你是做不到的。
你需要在 `crates.io` 上搜索 `utf8` 来寻找想要的功能。
可以考虑尝试下这个库:[utf8_slice](https://crates.io/crates/utf8_slice)。
可以考虑尝试下这个库[utf8_slice](https://crates.io/crates/utf8_slice)。
## 字符串深度剖析

@ -200,9 +200,9 @@ fn main() {
## 关联函数
现在大家可以思考一个问题,如何为一个结构体定义一个构造器方法?也就是接受几个参数,然后构造并返回该结构体的实例。其实答案在开头的代码片段中就给出了,很简单,不使用 `self`即可。
现在大家可以思考一个问题,如何为一个结构体定义一个构造器方法?也就是接受几个参数,然后构造并返回该结构体的实例。其实答案在开头的代码片段中就给出了,很简单,参数中不包含 `self` 即可。
这种定义在 `impl` 中且没有 `self` 的函数被称之为**关联函数** 因为它没有 `self`,不能用 `f.read()` 的形式调用,因此它是一个函数而不是方法,它又在`impl` 中,与结构体紧密关联,因此称为关联函数。
这种定义在 `impl` 中且没有 `self` 的函数被称之为**关联函数** 因为它没有 `self`,不能用 `f.read()` 的形式调用,因此它是一个函数而不是方法,它又在 `impl` 中,与结构体紧密关联,因此称为关联函数。
在之前的代码中,我们已经多次使用过关联函数,例如 `String::from`,用于创建一个动态字符串。

@ -95,7 +95,7 @@ sunface发表了微博好像微博没Tweet好用
上面我们将 `Summary` 定义成了 `pub` 公开的。这样,如果他人想要使用我们的 `Summary` 特征,则可以引入到他们的包中,然后再进行实现。
关于特征实现与定义的位置,有一条非常重要的原则:**如果你想要为类型 `A` 实现特征 `T`,那么 `A` 或者 `T` 至少有一个是在当前作用域中定义的!**例如我们可以为上面的 `Post` 类型实现标准库中的 `Display` 特征,这是因为 `Post` 类型定义在当前的作用域中。同时,我们也可以在当前包中为 `String` 类型实现 `Summary` 特征,因为 `Summary` 定义在当前作用域中。
关于特征实现与定义的位置,有一条非常重要的原则:**如果你想要为类型 `A` 实现特征 `T`,那么 `A` 或者 `T` 至少有一个是在当前作用域中定义的!**例如我们可以为上面的 `Post` 类型实现标准库中的 `Display` 特征,这是因为 `Post` 类型定义在当前的作用域中。同时,我们也可以在当前包中为 `String` 类型实现 `Summary` 特征,因为 `Summary` 定义在当前作用域中。
但是你无法在当前作用域中,为 `String` 类型实现 `Display` 特征,因为它们俩都定义在标准库中,其定义所在的位置都不在当前作用域,跟你半毛钱关系都没有,看看就行了。
@ -167,7 +167,7 @@ println!("1 new weibo: {}", weibo.summarize());
之前提到过,特征如果仅仅是用来实现方法,那真的有些大材小用,现在我们来讲下,真正可以让特征大放光彩的地方。
现在,先定义一个函数,使用特征用做函数参数:
现在,先定义一个函数,使用特征作为函数参数:
```rust
pub fn notify(item: &impl Summary) {
@ -175,7 +175,7 @@ pub fn notify(item: &impl Summary) {
}
```
`impl Summary`,只能说想出这个类型的人真的是起名鬼才,简直太贴切了,故名思义,它的意思是 `实现了Summary特征``item` 参数。
`impl Summary`,只能说想出这个类型的人真的是起名鬼才,简直太贴切了,故名思义,它的意思是 **实现了`Summary`特征**`item` 参数。
你可以使用任何实现了 `Summary` 特征的类型作为该函数的参数,同时在函数体内,还可以调用该特征的方法,例如 `summarize` 方法。具体的说,可以传递 `Post``Weibo` 的实例来作为参数,而其它类如 `String` 或者 `i32` 的类型则不能用做该函数的参数,因为它们没有实现 `Summary` 特征。
@ -456,7 +456,7 @@ fn main() {
}
```
上面代码中引入了 `std::convert::TryInto` 特征,但是却没有使用它,可能有些同学会为此困惑,主要原因在于**如果你要使用一个特征的方法,那么你需要引入该特征到当前的作用域中**,我们在上面用到了 `try_into` 方法,因此需要引入对应的特征。
上面代码中引入了 `std::convert::TryInto` 特征,但是却没有使用它,可能有些同学会为此困惑,主要原因在于**如果你要使用一个特征的方法,那么你需要将该特征引入当前的作用域中**,我们在上面用到了 `try_into` 方法,因此需要引入对应的特征。
但是 Rust 又提供了一个非常便利的办法,即把最常用的标准库中的特征通过 [`std::prelude`](https://course.rs/appendix/prelude.html) 模块提前引入到当前作用域中,其中包括了 `std::convert::TryInto`,你可以尝试删除第一行的代码 `use ...`,看看是否会报错。

Loading…
Cancel
Save