Rust note
Rust
《Rust 权威指南》读书笔记，本文将持续跟进
基础篇
Hello, world!
fn main() {
println!("Hello, world!");
}
println!是一个宏，负责打印。
变量声明
使用let 关键字进行声明：
let 变量名: 类型;
也可以同时赋初始值：
let 变量名: 类型 = 值;
编译器可对部分值的类型进行推导：
let 变量名 = 值;
变量类型——标量类型
1.整型
i8、i16、i32,i64、i128、isize
u8、u16、u32、u64、u128、usize
isize、usize为平台相关类型
let num: i32 = 100;
debug 模式下变量溢出会panic
release 模式下变量溢出会形成环绕，即最大数+1会变成该类型最小的数。若想显示环绕则使用标准库Wrapping类型。
| 整数字面量 | 示例 |
|---|---|
| Decimal | 999_999 |
| Hex | 0xff |
| Octal | 0o77 |
| Binary | 0b1010_0101 |
| Byte (u8 only) | b’Z’ |
默认推导类型：i32
2.浮点型
f32、f64
let num: f32 = 100.00;
浮点数遵循IEEE-754浮点数标准
默认推导类型：f64
3.布尔型
bool
let is_false: bool = false;
4.字符类型
char
let ch: char = 'a';
变量类型——复合类型
两种内置符合类型
1.元组类型
定义：
let tup: (i32, f32, bool) = (1, 2.0, true);
访问：
通过元组名.索引方式访问
tup.0、tup.1、tup.2
解构：
将元组拆分为多个变量
let (a, b, c) = tup;
2.数组类型
定义：
let a = [1, 2, 3, 4, 5, 6];
let a: [i32;6] = [1, 2, 3, 4, 5, 6];
let a: [3;6];等价于let a = [3, 3, 3, 3, 3, 3];
访问：
通过索引访问
a[0]、a[1]
变量的可变性与不可变性
使用以上方式声明的变量均不可修改，对其赋值会提示编译错误，其体现了变量的不可变性。
error[E0384]: cannot assign twice to immutable variable `a`
--> src\main.rs:31:5
|
30 | let (a,b,c) = tup;
| -
| |
| first assignment to `a`
| help: consider making this binding mutable: `mut a`
31 | a = 100;
| ^^^^^^^ cannot assign twice to immutable variable
若想声明可变的变量则在let 后加 mut 关键字(mut: mutable)。
如：let mut a: i32 = 100;此时对a赋值a = 200;是允许的。
变量的隐藏性
同一作用域内可以声明同名变量，下边的变量会隐藏上边的变量。即使类型不同也是可以的。
let a: i32 = 100;
let a: f32 = 100.0;
常量
定义：
const MAX_POINTS: u32 = 100_000;
访问：
可访问，不可修改。
函数
Rust 使用函数使用“蛇形命名”，即小写字母和下划线的组合方式。
无参无返回值形式
fn hello_rust() {
println!("hello, rust!")
}
有参有返回值形式
fn add_one(num :i32) -> i32 {
return num + 1;
}
函数内部也可以定义函数
fn main() {
fn add_one(num :i32) -> i32 {
return num + 1;
}
println!("{}",add_one(1));
}
使用表达式作为函数返回值，不需写return和结尾分号
fn main() {
println!("{}",add_one(1)); // 2
}
fn add_one(num :i32) -> i32 {
num + 1
}
处理多返回值可使用元组
fn f() -> (i32, i64, f32 ) {
(1, 2, 3.0)
}
语句
语句以英文半角下的“；”结尾。
表达式
fn main() {
let x = 15;
let y = {
let x = 20 + 1;
x + 5
};
println!("{}",y);
}
x + 6 称之为表达式，x = 后边的20 + 1也是表达式(有点像数学公式) ，表达式一般用一对{}(表示代码块或作用域)括起来，注意表达式一般写在代码块的最后，其后不写分号，写分号就变成了语句。
注释
// 单行注释,可放在语句末尾，分号后
/* 多行注释放在单行使用 */
/*
* 多行注释
* 多行注释
* 多行注释
*/
/// #这是文档注释
/// ## 可以写一些特殊的文本格式，如markdown
/// ```
/// fn f() -> (i32, i64, f32 ) //返回三个值
/// ```
fn f() -> (i32, i64, f32 ) {
(1, 2, 3.0)
}
控制流
if else
if
let a = 3;
if a > 2 {
println!("a > 2");
}
if else if
let a = 3;
if a > 4 {
println!("a > 4");
}else if a > 3{
println!("a > 3");
}else {
println!("what ?");
}
作为表达式使用，表达式中的值必须类型统一。如100、200。不可以为100，“hello”。
let a = 3;
let result = if a > 3 {
100
}else {
200
};
循环
rust 支持3种循环loop，for，while
break 用于打破循环，即跳出当前循环
continue 结束当前层循环
loop
let mut counter = 0;
loop {
counter += 1;
if counter == 100 {
println!("循环了100次");
break;
}
}
作为表达式使用
let mut counter = 0;
let result = loop {
counter += 1;
if counter == 10 {
break counter * 2; // 表达式的值
}
};
println!("The result is {}", result);
while
let mut number = 3;
while number != 0 {
println!("{}", number);
number = number - 1;
}
结束循环，跳转到tag处，常用于打破多重循环
let mut number = 3;
'tag: while number != 0 {
if number == 1 {
break 'tag;
}
println!("{}", number);
number = number - 1;
}
for
迭代数组
iter() 为迭代器
let a = [10, 20, 30, 40, 50];
for element in a.iter() {
println!("the value is: {}", element);
}
正向遍历与反向遍历
1…4 表示范围[1,4)，左闭右开，步长为1的从左往右遍历方式
(1…4).rev()：反向输出[1,4)的值
for number in 1..4 {
println!("{}", number);
}
for number in (1..4).rev() {
println!("{}", number);
}
所有权
Rust使用包含特定规则的所有权系统来管理内存，这套规则允许编译器在编译过程中执行检查工作，而不会产生任何的运行时开销。
所有权规则
Rust中的每一个值都有一个对应的变量作为它的所有者 。
在同一时间内，值有且仅有一个所有者。
当所有者离开自己的作用域时，它持有的值就会被释放掉。
变量作用域
Rust 用“{}”代表作用域。
变量在进入作用域后变得有效。它会保持自己的有效性直到自己离开作用域为止。
{ // 未定义变量s
let s = String::from("hello!"); // 变量s生效
} // 变量s离开作用域，Rust自动调用drop函数，销毁变量，归还内存给操作系统
变量和数据交互的方式——移动(所有权转移)
标量类型，因编译时期就可以明确的知道其占用的内存大小，不会涉及堆内存分配，将其完整的放在栈空间即可。所以b = a；复制了a 底层的数据3，两个3都在栈空间，相互独立。
let mut a = 3;
let mut b = a;
a += 100;
println!("{}",a); // 103
println!("{}",b); // 3
变量的移动(所有权转移)
以下代码设计到String的底层结构，String是一个既有栈上内存占用，又有堆上内存占用的数据结构，其发生赋值操作s2 = s1时，会将s1的栈上内容复制一份，给s2，同时将堆上内存的指针转移给s2。s2的出现代替了s1的存在，s1在发生赋值后，便不再可用。这样设计巧妙的避开了同一个内存区域被两次drop。
这其实就是一种浅拷贝操作，但会弃用被拷贝的变量。Rust称上述动作为移动(move)。Rust永远不会自动地创建数据的深度拷贝。因此在Rust中，任何自动的赋值操作都可以被视为高效的。
let s1 = String::from("hello");
let s2 = s1;
println!("{}",s1);
println!("{}",s2);
error[E0382]: borrow of moved value: `s1`
--> src\main.rs:31:19
|
28 | let s1 = String::from("hello");
| -- move occurs because `s1` has type `String`, which does not implement the `Copy` trait
29 | let s2 = s1;
| -- value moved here
30 |
31 | println!("{}",s1);
| ^^ value borrowed here after move
|
= note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
变量和数据交互的方式——克隆
深度拷贝，调用其clone()方法
let s1 = String::from("hello");
let s2 = s1.clone();
println!("s1 = {}, s2 = {}", s1, s2);
栈上数据赋值——实现Copy trait
trait 类似于其他语言的接口，描述了一系列行为。
Copy trait 负责栈上数据的拷贝工作，实现该trait即可将值复制给其他变量，原变量仍可用。
Drop trait 负责堆内存的释放工作。
同一种类型对于 Copy 和 Drop 只能实现其一。
内置的标量类型整型、浮点型、布尔型、字符型数据都实现了Copy trait。若元组中的所有数据类型都实现了Copy trait，那么该元组也具有被Copy的能力。
完整的存储在栈上的类型都可以实现Copy，只要有堆内存和引用其他资源的就不可以实现Copy，否则编译时报错。
用Copy 或 clone的方式对只保留在栈上的类型的数据进行复制都是可以的。
所有权与函数，参数、返回值、作用域
当函数的参数类型实现了Copy，那么传给函数参数的变量，在调用函数后，仍可使用。反之，则发生了所有权转移，参数的作用域即函数的作用域。在函数执行结束后，会自动调用drop，实现回收。所以，在函数调用处之后，是不可使用因调用函数而发生了所有权转移的变量的。若想继续使用该变量，可将其作为函数的返回值，返回后重新使用。引用可以解决这个壁垒。
引用
Rust 使用 & 代表引用语义，使用 * 代表解引用语义。
引用不持有所有权。
不可变引用——借用
let s1 = String::from("hello");
let s2 = &s1;
println!("{}",s1);
println!("{}",s2);
上述代码s2持有了s1的引用。
引用类型作为函数的参数
fn length(text: &String) -> usize {
text.len()
}
调用上述length函数，不会发生所有权转移，在函数退出时，不销毁传入的参数text。
不可变的引用也称之为借用(borrow)。对length函数中的text参数进行修改是不被允许的。
可变引用
作为函数参数，表示为s: &mut String
fn change_string(s: &mut String) {
s.push_str("_修改后的.");
}
let mut s1 = String::from("hello");
change_string(&mut s1);
println!("{}",s1);
以下代码比较难以理解。在使用可变引用时比较迷惑人。
同一时刻，一个变量只能有一个可变引
如下操作不被允许
let mut s1 = String::from("hello");
let mut s2 = &mut s1; //------
s1.push_str("_1"); // | 可变引用s2,被操作时，不能交叉操作s1
s2.push_str("_2"); //--------
error[E0499]: cannot borrow `s1` as mutable more than once at a time
--> src\main.rs:38:5
|
37 | let mut s2 = &mut s1;
| ------- first mutable borrow occurs here
38 | s1.push_str("_1");
| ^^^^^^^^^^^^^^^^^ second mutable borrow occurs here
39 | s2.push_str("_2");
| ----------------- first borrow later used here
如下操作同样不被允许
let mut s1 = String::from("hello");
let mut s2 = &mut s1;
let mut s3 = &mut s1;
s2.push_str("hh");
error[E0499]: cannot borrow `s1` as mutable more than once at a time
--> src\main.rs:38:18
|
37 | let mut s2 = &mut s1;
| ------- first mutable borrow occurs here
38 | let mut s3 = &mut s1;
| ^^^^^^^ second mutable borrow occurs here
39 | s2.push_str("hh");
| ----------------- first borrow later used here
如下操作被允许
let mut s1 = String::from("hello");
let mut s2 = &mut s1;
s2.push_str("_2");
s1.push_str("_1");
使用作用域隔离可变引用
let mut s1 = String::from("hello");
{
let mut s2 = &mut s1;
s2.push_str("hh");
}
let mut s3 = &mut s1;
println!("{}",s3);
println!("{}",s1);
发生数据竞争的条件：
1.两个或两个以上的指针同时访问同一空间。
2.其中至少有一个指针会向空间中写入数据。
3.没有同步数据访问的机制。
操作可变引用后，不可以操作原来的不可变引用
允许的
let mut s1 = String::from("hello");
let r1 = &s1;
let r2 = &s1;
println!("{}-{}",r1,r2);
let r3 = &mut s1;
println!("{}",r3);
不允许的
let mut s1 = String::from("hello");
let r1 = &s1;
let r2 = &s1;
println!("{}-{}",r1,r2);
let r3 = &mut s1;
println!("{}",r3);
println!("{}",r1);
error[E0502]: cannot borrow `s1` as mutable because it is also borrowed as immutable
--> src\main.rs:40:14
|
37 | let r1 = &s1;
| --- immutable borrow occurs here
...
40 | let r3 = &mut s1;
| ^^^^^^^ mutable borrow occurs here
41 | println!("{}",r3);
42 | println!("{}",r1);
| -- immutable borrow later used here
悬垂引用
未引入生命周期，悬垂引用不被允许
fn main() {
let reference_to_nothing = dangle();
}
fn dangle() -> &String {
let s = String::from("hello");
&s
}
error[E0106]: missing lifetime specifier
--> src\main.rs:39:16
|
39 | fn dangle() -> &String {
| ^ expected named lifetime parameter
|
= help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime
|
39 | fn dangle() -> &'static String {
| +++++++
引用规则
在任何一段给定的时间里，要么只能拥有一个可变引用，要么只能拥有任意数量的不可变引用，引用总是有效的。
切片
切片是一种特殊的引用形式。其不持有所有权。
切片允许我们引用集合中某一段连续的元素序列。
将整个集合转换成切片
let slice = 集合[..];
将集合一部分转换成切片
let slice = 集合[1..];// 从索引1到集合最后
let slice = 集合[1..2];// 从索引1到索引2
let slice = 集合[..2];// 从索引0到索引2
let slice = 集合[0..3];// 从索引0到索引3
切片中[start…end]，start与end构成的是一个左闭右开的区间[start,end)
字符串切片
let s = String::from("hello world");
let hello = &s[0..5];
let world = &s[6..11];
println!("{}",hello);
println!("{}",world);
对字符串切片时需考虑字符边界问题，UTF-8编码使用1-4字节表示一个字符。
字符串字面量就是切片。
let s = "hello, world";
let s :&str = "hello world";
str类型即字符串切片类型。
结构体
定义方式
struct 结构体名 {
字段名0:类型,
字段名1:类型,
}
访问方式
对象.字段名
定义User结构体
struct User {
name: String,
age: i32,
}
使用User结构体
let user= User{
name: "ophelia".to_string(),
age:13,
};
println!("{:?}",user.name);
println!("{:?}",user.age);
用函数方式创建User对象
fn new_user(name: String, age: i32) -> User {
User{
name:name,
age: age,
}
}
若函数形参名与结构体中字段重合，则不用写结构体的字段名,直接写入形参
fn new_user_two(name: String, age: i32) -> User {
User{
name,
age,
}
}
let mut user = new_user(String::from("张三"),20);
user.age = 22;
println!("{}",user.age);
let user = new_user_two(String::from("李四"),20);
println!("{}",user.name);
使用已有的结构体中的字段
方式1
let user = new_user_two(String::from("李四"),20);
//使用其他user中的字段创建user
let user1 = User{
name:String::from("judy"),
age:user.age,
};
方式2 …运算符。语法糖。
let user = new_user_two(String::from("李四"),20);
//使用其他user中的字段创建user
let user1 = User{
name:String::from("julia"),
..user
};
元组结构体
定义方式
struct 结构体名(类型1,类型2,类型3);
访问方式
对象.索引
定义元组结构体
struct Color(i32, i32, i32);
struct Point(i32, i32, i32);
let black = Color(0, 0, 0);
let origin = Point(0, 0, 0);
println!("{}",black.0);
空结构体
定义方式
struct 结构体名 {}
空结构体一般用作实现trait。实现trait时，不需要使用结构体中的数据。
空结构体与空元组类似 let tup = ();
结构体数据的所有权
若结构体中所有字段都是非引用类型，那么只要结构体携带的数据时有效的，那么结构体就是有效的若结构体中有字段为引用类型，则需要引入生命周期的概念。
为结构体添加派生宏，Debug，实现打印功能
不在结构体上添加 #[derive(Debug)]是无法实现打印功能的。
还需要修改打印宏的占位符的参数 println!("{:?}",user); 加上:?。
#[derive(Debug)]
struct User {
name: String,
age: i32,
}
let user= User{
name: "ophelia".to_string(),
age:13,
};
println!("{:?}",user); // User { name: "ophelia", age: 13 }
方法
方法与函数类似：都使用fn关键字及一个名称来进行声明；它们都可以拥有参数和返回值；另外，它们都包含了一段在调用时执行的代码。但是，方法与函数依然是两个不同的概念，因为方法总是被定义在某个结构体（或者枚举类型、trait对象）的上下文中，并且它们的第一个参数永远都是self，用于指代调用该方法的结构体实例。
定义方式
impl 结构体名 {
fn 方法名0(self,参数1:类型) -> 返回值类型 {
返回值
}
fn 方法名1(&self,参数1:类型,参数2:类型) -> 返回值类型 {
返回值
}
fn 方法名2(&mut self,参数1:类型) -> 返回值类型 {
返回值
}
fn 函数名(参数1:类型)-> 返回值类型 {
返回值
}
}
代码
#[derive(Debug)]
struct User {
name: String,
age: i32,
}
impl User {
fn say(&self) {
println!("say");
}
fn println(&mut self) {
self.name = String::from("张三");
println!("{:?}",self);
}
fn new_user(name:String, age:i32) ->User { // 关联函数，第一个参数非self，常用于结构体的构造器
User{
name,
age,
}
}
}
fn main() {
let mut user = User{
name:String::from("judy"),
age: 16
};
let mut user = User::new_user(String::from("judy"),15);
user.say();
user.println();
}
关联函数
为结构体绑定函数,但是函数参数不传入self。则称之为关联函数，关联函数常用于创建对象。
访问方式一般为: let 变量名 = 结构体::关联函数名(参数);
impl User {
fn say(&self) {
println!("say");
}
fn println(&mut self) {
self.name = String::from("张三");
println!("{:?}",self);
}
fn new_user(name:String, age:i32) ->User { // 关联函数，第一个参数非self，常用于结构体的构造器
User{
name,
age,
}
}
}
多impl块
Rust 支持将实现同一类型的方法，拆分到多个impl块中
impl User {
fn get_name(self) ->String {
self.name
}
}
impl User {
fn get_age(self) ->i32 {
self.age
}
}
枚举
定义
这里的变体就是枚举值
enum 枚举名 {
变体1,
变体2(类型),
}
访问
枚举名::变体名(参数)
或
变体名(参数)
代码
枚举中支持匿名结构体及空结构体struct Name;
#[derive(Debug)]
enum Paper {
White(String),
Black,
Blue {x:i32,y:i32},
Pink(i32,i32,i32)
}
fn main() {
let p = Paper::Black;
println!("{:?}",p);
println!("{:?}",Paper::White(String::from("白色")));
}
可以将枚举类型加入结构体中。
也可为枚举类型绑定方法，与结构体绑定方法大同小异。
标准库中的枚举 Option
该枚举可以表示非空值与空值。他有Some(T)，和None两个变体。Some表示值非空，None表示值为空
let str1 = Some("hello");
let str1 = None;
控制流运算符 match
match允许将一个值与一系列的模式相比较，并根据匹配的模式执行相应代码。模式可由字面量、变量名、通配符和许多其他东西组成。
let op :Option<i32> = Some(128);
match op {
Some(op) => {
println!("有值")
},
None => {
println!("无值")
}
}
作为表达式使用
_ 代表通配符
_ => {} 为默认匹配模式，只有一条表达式时，{}可不写
let value = 100;
let result = match value {
10 => {
10 + 2
},
90 => {
90 + 3
}
_ => 0
};
println!("{}",result); // 0
包、单元包、模块
包与模块的划分是为了更好的管理、维护、复用代码。
包(package)
包：一个用于构建、测试并分享单元包的Cargo功能。
一个包（package）可以拥有多个二进制单元包及一个可选的库单元包。
单元包(crate)
单元包：一个用于生成库或可执行文件的树形模块结构。
可将部分代码拆分到独立的单元包（crate）中，并将它作为外部依赖进行
引用。
cargo new Rust创建项目Rust
项目结构
Rust
|-------src
| |----------main.rs
|-------target
| |----------debug
| |------------一系列目录与文件，包括生成的可执行文件
|--------Cargo.lock
|--------Cargo.toml
Cargo会默认将src/main.rs 视作一个二进制单元包的根节点，这个二进制单元包与包拥有相同的名称。
模块(module) 及 use
它们被用于控制文件结构、作用域及路径的私有性。
通过定义模块来控制作用域及私有性：
mod 模块名 {
// 代码...
}
pub mod 模块名 {
// 代码...
}
模块中可以嵌套的定义模块。
通过使用模块，可以将相关的定义分到一组，并根据它们的关系指定有意义的名称。
路径(path)
一种用于命名条目的方法，这些条目包括结构体、函数和模块等。
用于在模块树中指明条目的路径：
路径有两种形式：
1.使用单元包名或字面量crate从根节点开始的绝对路径。
2.使用self、super或内部标识符从当前模块开始的相对路径。
绝对路径与相对路径都由至少一个标识符组成，标识符之间使用双冒号（::）分隔。
Rust中的所有条目（函数、方法、结构体、枚举、模块及常量）默认都是私有的。
使用pub关键字来暴露路径：
pub mod user_mod {
pub mod action_mod {
pub fn Do(){
println!("do something!")
}
}
#[derive(Debug)]
pub struct User {
name: String,
age: i32,
}
impl User {
fn say(&self) {
println!("say");
}
pub fn println(self) {
println!("{:?}",self);
}
pub fn new_user(name:String, age:i32) ->User { // 关联函数，第一个参数非self，常用于结构体的构造器
User{
name,
age,
}
}
fn get_name(self) ->String {
self.name
}
fn get_age(self) ->i32 {
self.age
}
}
}
使用super关键字开始构造相对路径
fn hello() {
println!("hello!")
}
pub mod test {
fn hello() {
super::hello();
}
}
将结构体或枚举声明为公共的
pub mod test_one {
pub struct Person {
pub name: String, // 需逐个公开
age: i32,
}
pub enum Action { //枚举只要公开一个成员，即公开了所有成员
Song,
Jump,
Rap,
}
}
用use关键字将路径导入作用域
未使用use之前
fn main() {
//绝对路径
let user = crate::user_mod::User::new_user(String::from("张三"),12);
user.println(); // User { name: "张三", age: 12 }
//相对路径
let user = user_mod::User::new_user(String::from("张三"),12);
user.println(); // User { name: "张三", age: 12 }
}
使用use之后
use crate::user_mod::User;
fn main() {
//绝对路径
let user = User::new_user(String::from("张三"),12);
user.println(); // User { name: "张三", age: 12 }
//相对路径
let user = User::new_user(String::from("张三"),12);
user.println(); // User { name: "张三", age: 12 }
}
使用as关键字来提供新的名称
use crate::user_mod::User as U;
fn main() {
//绝对路径
let user = U::new_user(String::from("张三"),12);
user.println(); // User { name: "张三", age: 12 }
//相对路径
let user = U::new_user(String::from("张三"),12);
user.println(); // User { name: "张三", age: 12 }
}
使用pub use重导出名称
不仅将条目引入了作用域，而且使该条目可以被外部代码从新的作用域引入自己的作用域。
pub use crate::user_mod::User;
其他包在导入该包后，可访问该包因如的User。
使用外部包
更新Cargo.toml文件
Cargo.toml
[dependencies]
rand = "0.5.5"
在dependencies下指定包名，版本号，用use 导入即可使用。
使用嵌套的路径来清理众多use语句
use std::cmp::Ordering;
use std::io;
use std::{cmp::Ordering, io};
通配符*
use std::collections::*;
将模块拆分为不同的文件
原文件
// src/lib.rs
mod front_of_house {
pub mod hosting {
pub fn add_to_waitlist() {}
}
}
pub use crate::front_of_house::hosting;
pub fn eat_at_restaurant() {
hosting::add_to_waitlist();
hosting::add_to_waitlist();
hosting::add_to_waitlist();
}
拆分后的文件
// src/lib.rs
mod front_of_house; // 声明front_of_house模块,让Rust前往与当前模块同名的文件中加载模块内容。
pub use crate::front_of_house::hosting;
pub fn eat_at_restaurant() {
hosting::add_to_waitlist();
hosting::add_to_waitlist();
hosting::add_to_waitlist();
}
// src/front_of_house.rs
pub mod hosting;
// src/front_of_house/hosting.rs
pub fn add_to_waitlist() {}
工作空间(workspace)
该特性与Cargo相关，后续介绍
作用域(scope)
在编写代码的嵌套上下文中有一系列被定义在“作用域内”的名字。可以创建作用域并决定某个名字是否处于该作用域中，但是不能在同一作用域中使用相同的名字指向两个不同的条目；有一些工具可以被用来解决命名冲突。
通用集合类型
vector
动态数组（vector）可以让你连续地存储任意多个值。数据存储在堆上。
创建
let v: Vec
使用宏创建并赋初值
let v = vec![1, 2, 3];
插入
v.push(5);
v.push(6);
v.push(7);
v.push(8);
读取
let v = vec![1, 2, 3, 4, 5];
let third: &i32 = &v[2];
println!("The third element is {}", third);
match v.get(2) {
Some(third) => println!("The third element is {}", third),
None => println!("There is no third element."),
}
遍历
let v = vec![100, 32, 57];
for i in &v {
println!("{}", i);
}
let mut v = vec![100, 32, 57];
for i in &mut v {
*i += 50;
}
使用枚举存储多个类型
enum SpreadsheetCell {
Int(i32),
Float(f64),
Text(String),
}
let row = vec![
SpreadsheetCell::Int(3),
SpreadsheetCell::Text(String::from("blue")),
SpreadsheetCell::Float(10.12),
];
String
字符串（string）是字符的集合。&str 是字符串切片。Rust的标准库中同时包含了其他一系列的字符串类型，比如OsString、OsStr、CString及CStr。
创建
let mut s = String::new();
创建字面量
let data = "initial contents";
let s = data.to_string();
从字面量生成
let s = String::from("initial contents");
更新 push_str 或 push
let mut s = String::from("foo");
s.push_str("bar");
s.push('a');
遍历
for c in "你好，world!".chars() {
println!("{}", c);
}
for c in "你好，world!".bytes() {
println!("{}", c);
}
索引
Rust 字符串使用UTF-8字符编码，字符长度不固定。不支持索引。
切片
做切片时应充分考虑边界问题。
HashMap
哈希映射（hash map）可以让你将值关联到一个特定的键上，
它是另外一种数据结构—映射 （map）的特殊实现。数据存储在堆上。
创建
use std::collections::HashMap;
let mut scores = HashMap::new();
scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);
哈希映射与所有权
一旦键值对被插入，其所有权就会转移给哈希映射。假如我们只是将值的引用插入哈希映射，那么这些值是不会被移动到哈希映射中的。
访问哈希映射中的值
use std::collections::HashMap;
let mut scores = HashMap::new();
scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);
let team_name = String::from("Blue");
let score = scores.get(&team_name);
更新哈希映射，旧值覆盖
use std::collections::HashMap;
let mut scores = HashMap::new();
scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Blue"), 25);
println!("{:?}", scores);
只在键没有对应值时插入数据
use std::collections::HashMap;
let mut scores = HashMap::new();
scores.insert(String::from("Blue"), 10);
scores.entry(String::from("Yellow")).or_insert(50);
scores.entry(String::from("Blue")).or_insert(50);
println!("{:?}", scores);
基于旧值来更新值
use std::collections::HashMap;
let text = "hello world wonderful world";
let mut map = HashMap::new();
for word in text.split_whitespace() {
let count = map.entry(word).or_insert(0);
*count += 1;
}
println!("{:?}", map);