语言基础

变量与可变性

变量默认是不可改变的（immutable），不能对不可变变量二次赋值

  • 使用 let 创建变量，变量不能重复赋值
  • 在变量名前添加 mut 来使其可变，但不能改变其类型
  • 使用 const 创建常量（使用下划线分隔的大写字母单词），不可对其使用 mut

  • 隐藏（shadowing）：用相同的变量名来隐藏前一个变量，可改变其类型 

    1. let spaces = "   ";
    2. let spaces = spaces.len();

    数据类型

    Rust 是静态类型语言（statically typed），在编译时必须知道所有变量的类型。

  • 标量（scalar）

  • 复合（compound）

    标量（scalar）

    代表一个单独的值

  • 整型

  • 浮点型
  • 布尔

  • 字符类型

    整型

    微信截图_20210118164849.png

    浮点型

  • f64：默认类型，双精度浮点数

  • f32：单精度浮点数

    1. fn main() {
    2.   let x = 2.0; // f64
    4.   let y: f32 = 3.0; // f32
    5. }

布尔值

  1. fn main() {
  2.     let t = true;
  4.     let f: bool = false; // 显式指定类型注解
  5. }

字符类型（the character type）

Rust 的 char 类型是语言中最原生的字母类型（注意 char 由单引号指定，不同于字符串使用双引号。）

  1. fn main() {
  2.     let c = 'z';
  3.     let z = 'ℤ';
  4.     let heart_eyed_cat = '😻';
  5. }

复合（compound）

  • 元组（tuple）
  • 数组（array）

    元组（tuple）

    将多个其他类型的值组合进一个复合类型，使用包含在圆括号中的逗号分隔的值列表来创建一个元组

  1. fn main() {
  2.     let tup = (500, 6.4, 1);
  4.     // 解构（destructuring）
  5.     let (x, y, z) = tup;
  7.     // 使用点号（.）后跟值的索引来直接访问
  8.     let five_hundred = x.0;
  10.     let six_point_four = x.1;
  12.     let one = x.2;
  14.     println!("The value of y is: {}", y);
  15. }

数组（array）

数组中的每个元素的类型必须相同。Rust 中的数组是固定长度的（一旦声明，它们的长度不能增长或缩小)

  1. // [类型; 长度]
  2. let a: [i32; 5] = [1, 2, 3, 4, 5];

函数

Rust 中的函数定义以 fn 开始并在函数名（所有字母都是小写并使用下划线分隔单词）后跟一对圆括号。大括号告诉编译器哪里是函数体的开始和结尾。

  • 函数参数：声明时必须指定类型

  • 如果有返回值，要在箭头（->）后声明它的类型

    语句和表达式

    Rust 是一门基于表达式（expression-based）的语言

  • 语句（Statements）是执行一些操作但不返回值的指令。

  • 表达式（Expressions）计算并产生一个值，{}也是一个表达式，表达式的结尾没有分号 ```rust fn main() { let x = plus_one(5);

    println!(“The value of x is: {}”, x);

    let y = {

    1.   let x = 3;
    2.   // 表达式的结尾没有分号
    3.   x + 1

    };

    println!(“The value of y is: {}”, y); }

fn plus_one(x: i32) -> i32 { x + 1 }

  1. <a name="dNnIJ"></a>
  2. ## 控制流（Control Flow）
  4. - if
  5. - loops
  6. - while
  7. - for
  8. <a name="Iuw9x"></a>
  9. ### if 表达式
  10. > Rust 不会尝试自动地将非布尔值转换为布尔值
  12. ```rust
  13. fn main() {
  14.     let number = 6;
  16.     if number % 4 == 0 {
  17.         println!("number is divisible by 4");
  18.     } else if number % 3 == 0 {
  19.         println!("number is divisible by 3");
  20.     } else if number % 2 == 0 {
  21.         println!("number is divisible by 2");
  22.     } else {
  23.         println!("number is not divisible by 4, 3, or 2");
  24.     }
  25. }

if 的每个分支的可能的返回值都必须是相同类型

  1. fn main() {
  2.     let condition = true;
  3.     let number = if condition {
  4.         5
  5.     } else {
  6.         //这里只能返回数字类型
  7.         6
  8.     };
  10.     println!("The value of number is: {}", number);
  11. }

loops

loop 关键字告诉 Rust 一遍又一遍地执行一段代码，可以使用 break 关键字来告诉程序何时停止循环

  1. fn main() {
  2.     let mut counter = 0;
  4.     let result = loop {
  5.         counter += 1;
  7.         if counter == 10 {
  8.             break counter * 2;
  9.         }
  10.     };
  12.     assert_eq!(result, 20);
  13. }

while

  1. fn main() {
  2.     let mut number = 3;
  4.     while number != 0 {
  5.         println!("{}!", number);
  7.         number = number - 1;
  8.     }
  10.     println!("LIFTOFF!!!");
  11. }

for

  1. fn main() {
  2.     let a = [10, 20, 30, 40, 50];
  4.     for element in a.iter() {
  5.         println!("the value is: {}", element);
  6.     }
  7. }

所有权（ownership）

Rust 通过所有权系统管理内存

什么是所有权

所有权规则

  1. Rust 中的每一个值都有一个被称为其 所有者（owner）的变量
  2. 值有且只有一个所有者

  3. 当所有者（变量）离开作用域（scope），这个值将被丢弃

    堆和栈

  4. 编译时数据的类型大小是固定的，分配在栈上

  5. 数据类型大小不固定，分配在堆上

    变量作用域

    String 类型

    这个类型被分配到堆上，所以能够存储在编译时未知大小的文本。可以使用 from 函数基于字符串字面值来创建 String

  1. let mut s = String::from("hello");
  3. s.push_str(", world!"); // push_str() 在字符串后追加字面值
  5. println!("{}", s); // 将打印 `hello, world!`

对于 String 类型，为了支持一个可变，可增长的文本片段，需要在堆上分配一块在编译时未知大小的内存来存放内容。这意味着：

  • 必须在运行时向操作系统请求内存
  • 需要一个当我们处理完 String 时将内存返回给操作系统的方法

    内存与分配

    Rust 采取的策略：内存在拥有它的变量离开作用域后就被自动释放

  1. {
  2.     let s = String::from("hello"); // 从此处起，s 是有效的
  4.     // 使用 s
  5. }                                  // 此作用域已结束，
  6.                                    // s 不再有效

在变量离开作用域时 Rust 会调用一个 drop 函数并清理变量的堆内存

变量与数据交互的方式（一）：移动（Move）

在进行赋值（let x = y）或通过值来传递函数参数（foo(x)）的时候，资源 的所有权（ownership）会发生转移。资源只能拥有一个所有者。这防止了 资源的重复释放。在移动资源之后，原来的所有者不能再被使用

  1. let s1 = String::from("hello");
  2. let s2 = s1;

微信截图_20210118181006.png

变量与数据交互的方式（二）：克隆（Clone）

使用 Clone 函数深度复制 String 中堆上的数据，而不仅仅是栈上的数据

  1. let s1 = String::from("hello");
  2. let s2 = s1.clone();
  4. println!("s1 = {}, s2 = {}", s1, s2);

只在栈上的数据：拷贝
  • 所有整数类型
  • 布尔
  • 浮点数
  • 字符类型，char
  • 元组，当且仅当包含的类型也都是 Copy 的时候。 ```rust let x = 5; let y = x;

println!(“x = {}, y = {}”, x, y);

  1. <a name="xHNM5"></a>
  2. #### 所有权与函数
  3. ```rust
  4. fn main() {
  5.     let s = String::from("hello");  // s 进入作用域
  7.     takes_ownership(s);             // s 的值移动到函数里 ...
  8.                                     // ... 所以到这里不再有效
  10.     let x = 5;                      // x 进入作用域
  12.     makes_copy(x);                  // x 应该移动函数里，
  13.                                     // 但 i32 是 Copy 的，所以在后面可继续使用 x
  15. } // 这里, x 先移出了作用域，然后是 s。但因为 s 的值已被移走，
  16.   // 所以不会有特殊操作
  18. fn takes_ownership(some_string: String) { // some_string 进入作用域
  19.     println!("{}", some_string);
  20. } // 这里，some_string 移出作用域并调用 `drop` 方法。占用的内存被释放
  22. fn makes_copy(some_integer: i32) { // some_integer 进入作用域
  23.     println!("{}", some_integer);
  24. } // 这里，some_integer 移出作用域。不会有特殊操作

返回值与作用域

  1. fn main() {
  2.     let s1 = gives_ownership();         // gives_ownership 将返回值
  3.                                         // 移给 s1
  5.     let s2 = String::from("hello");     // s2 进入作用域
  7.     let s3 = takes_and_gives_back(s2);  // s2 被移动到
  8.                                         // takes_and_gives_back 中, 
  9.                                         // 它也将返回值移给 s3
  10. } // 这里, s3 移出作用域并被丢弃。s2 也移出作用域，但已被移走，
  11.   // 所以什么也不会发生。s1 移出作用域并被丢弃
  13. fn gives_ownership() -> String {             // gives_ownership 将返回值移动给
  14.                                              // 调用它的函数
  16.     let some_string = String::from("hello"); // some_string 进入作用域.
  18.     some_string                              // 返回 some_string 并移出给调用的函数
  19. }
  21. // takes_and_gives_back 将传入字符串并返回该值
  22. fn takes_and_gives_back(a_string: String) -> String { // a_string 进入作用域
  24.     a_string  // 返回 a_string 并移出给调用的函数
  25. }

引用（References）与借用（Borrowing）

使用值但不获取其所有权，函数签名使用 & 来表明参数 s 的类型是一个引用。将获取引用作为函数参数称为 借用（borrowing）。默认不允许修改引用的值。

  1. fn main() {
  2.     let s1 = String::from("hello");
  4.     let len = calculate_length(&s1);
  6.     println!("The length of '{}' is {}.", s1, len);
  8.     let r1 = String::from("hello");
  9.     let r2 = &mut r1;
  10.     r2.push_str(", hhh");
  11. }
  13. fn calculate_length(s: &String) -> usize { // s 是对 String 的引用
  14.     s.len()
  15. } // 这里，s 离开了作用域。但因为它并不拥有引用值的所有权，
  16.   // 所以什么也不会发生

微信截图_20210118201007.png

可变引用（Mutable References）

  • 先将变量设为可变变量 mut s
  • 再创建一个可变引用 &mut s

在特定作用域中的特定数据有且只有一个可变引用，就是说同一个作用域你不能搞出两个 &mut s
不能在拥有不可变引用的同时拥有可变引用，就是你不能同时使用 &s 和 &mut s

  1. fn main() {
  2.     let mut s = String::from("hello");
  4.     change(&mut s);
  5. }
  7. fn change(some_string: &mut String) {
  8.     some_string.push_str(", world");
  9. }

垂直引用（Dangling References）

就是你引用到了一个已经释放了内存的变量 

  1. fn dangle() -> &String { // dangle 返回一个字符串的引用
  3.     let s = String::from("hello"); // s 是一个新字符串
  5.     &s // 返回字符串 s 的引用
  6. } // 这里 s 离开作用域并被丢弃。其内存被释放。
  7.   // 危险！

应该直接把所有权移动出去

  1. fn main() {
  2.     let reference_to_nothing = dangle();
  3. }
  5. fn no_dangle() -> String {
  6.     let s = String::from("hello");
  8.     s
  9. }

引用的规则

  • 在任意给定时间，要么 只能有一个可变引用，要么 只能有多个不可变引用
  • 引用必须总是有效

    切片（slices）

    slice是一个没有所有权的数据类型，其允许你引用集合中一段连续的元素序列，而不引用整个集合。 Slices are borrowed, that’s to say, they are passed by reference to a function and a slice’s size is determined at runtime.

  1. let s = String::from("hello world");
  3. let len = s.len();
  5. let hello = &s[0..5];
  6. //= 意味着包含最后的数字
  7. let hellos = &s[0..=4];
  8. let slice = &s[..2];
  9. let slice = &s[3..];
  10. let slice = &s[0..len];
  11. let slice = &s[..];

结构体（Structs）

struct，或者 structure，是一个自定义数据类型，允许你命名和包装多个相关的值，从而形成一个有意义的组合。 在大括号中，定义每一部分数据的名字和类型，我们称为 字段（field）

  1. struct User {
  2.     username: String,
  3.     email: String,
  4.     sign_in_count: u64,
  5.     active: bool,
  6. }
  8. let user1 = User {
  9.     email: String::from("someone@example.com"),
  10.     username: String::from("someusername123"),
  11.     active: true,
  12.     sign_in_count: 1,
  13. };
  15. //.. 语法指定了剩余未显式设置值的字段应有与给定实例对应字段相同的值
  16. let user2 = User {
  17.     email: String::from("another@example.com"),
  18.     username: String::from("anotherusername567"),
  19.     ..user1
  20. };
  22. fn build_user(email: String, username: String) -> User {
  23.     User {
  24.         email,
  25.         username,
  26.         active: true,
  27.         sign_in_count: 1,
  28.     }
  29. }

方法（Method）

依附于对象的函数，第一个参数总是 self，它代表调用该方法的结构体实例。 在 impl 代码块中定义

  1. #[derive(Debug)]
  2. struct Rectangle {
  3.     width: u32,
  4.     height: u32,
  5. }
  7. impl Rectangle {
  8.     fn area(&self) -> u32 {
  9.         self.width * self.height
  10.     }
  11. }
  13. fn main() {
  14.     let rect1 = Rectangle { width: 30, height: 50 };
  16.     println!(
  17.         "The area of the rectangle is {} square pixels.",
  18.         rect1.area()
  19.     );
  20. }

枚举（Enum）

枚举 enum，用于从众多选项中选择一个

  1. enum IpAddrKind {
  2.     V4,
  3.     V6,
  4. }
  6. struct IpAddr {
  7.     kind: IpAddrKind,
  8.     address: String,
  9. }
  11. let home = IpAddr {
  12.     kind: IpAddrKind::V4,
  13.     address: String::from("127.0.0.1"),
  14. };
  16. let loopback = IpAddr {
  17.     kind: IpAddrKind::V6,
  18.     address: String::from("::1"),
  19. };

用枚举代替结构体

可以给枚举的每一个成员，指定一个数据类型，并且在创建一个枚举变量的时候，将某个值存入枚举

  1. // 定义一个操作枚举
  2. #[derive(Debug)]
  3. enum Operation {
  4.     Move {x: i32, y:i32},
  5.     Jump(u32),
  6.     Attack(i32),
  7. }
  9. fn main() {
  10.     // 定义一个移动的操作
  11.     let opt_move = Operation::Move {x: 10, y: 11};
  13.     // 定义一个攻击的操作
  14.     let opt_attack = Operation::Attack(100);
  16.     // 定义一个跳跃的操作
  17.     let opt_jump = Operation::Jump(3);
  19.     DoOperation(opt_move);
  20.     DoOperation(opt_attack);
  21.     DoOperation(opt_jump);
  22. }
  24. // 执行操作
  25. fn DoOperation(opt: Operation) {
  26.     println!("Do operation: {:?}", opt);
  27. }

Option 枚举

使用 Option 作为存在值和空值间的选择，因为 Option 可以被赋予指定类型，即使当变量还为初始化时，也是明确变量应该被设置的类型

  1. enum Option {
  2.     Some(T),
  3.     None,
  4. }
  1. let some_number = Some(5);
  2. let some_string = Some("a string");
  4. let absent_number: Option<i32> = None;  //当变量暂不可知时，赋予None

match 控制流运算符

match 表达式是一个处理枚举的控制流结构：它会根据枚举的成员运行不同的代码，这些代码可以使用匹配到的值中的数据。 the match keyword which behaves the same way as a switch statement would (Rust does not have switch).

  1. let num = 101;
  3. if num < 100 {
  4.     println!("{} is less than 100", num)
  5. } else if num > 100 {
  6.     println!("{} is more than 100", num)
  7. } else if num == 100 {
  8.     println!("{} is equal 100", num)
  9. }

当 match 表达式执行时，它将结果值按顺序与每一个分支的模式相比较。如果模式匹配了这个值，这个模式相关联的代码将被执行。如果模式并不匹配这个值，将继续执行下一个分支。
每个分支相关联的代码是一个表达式，而表达式的结果值将作为整个 match 表达式的返回值。

  1. enum Choice {
  2.     One,
  3.     Two,
  4.     Three,
  5. }
  7. //suppose this was passed by the user and you stored in a variable
  8. let choice = Choice::One; 
  9. match choice {
  10.     Choice::One => println!("Option 1"),
  11.     Choice::Two => println!("Option 2"),
  12.     Choice::Three => println!("Option 3"),
  13. }

匹配 Option

  1. fn plus_one(x: Option<i32>) -> Option<i32> {
  2.     match x {
  3.         None => None,
  4.         Some(i) => Some(i + 1),
  5.     }
  6. }
  8. let five = Some(5);
  9. let six = plus_one(five);
  10. let none = plus_one(None);

_ 通配符

_ 模式会匹配所有的值。通过将其放置于其他分支之后，_ 将会匹配所有之前没有指定的可能的值。

  1. let some_u8_value = 0u8;
  2. match some_u8_value {
  3.     1 => println!("one"),
  4.     3 => println!("three"),
  5.     5 => println!("five"),
  6.     7 => println!("seven"),
  7.     _ => (),
  8. }

if let 简洁控制流

  1. # #[derive(Debug)]
  2. # enum UsState {
  3. #    Alabama,
  4. #    Alaska,
  5. # }
  6. #
  7. # enum Coin {
  8. #    Penny,
  9. #    Nickel,
  10. #    Dime,
  11. #    Quarter(UsState),
  12. # }
  13. # let coin = Coin::Penny;
  14. let mut count = 0;
  15. match coin {
  16.     Coin::Quarter(state) => println!("State quarter from {:?}!", state),
  17.     _ => count += 1,
  18. }
  20. if let Coin::Quarter(state) = coin {
  21.     println!("State quarter from {:?}!", state);
  22. } else {
  23.     count += 1;
  24. }

包管理 （Packages）

  • 包（Packages）是 Cargo 的一个功能，它允许你构建、测试和分享 crate。
  • Crates 是一个模块的树形结构，它形成了库或二进制项目。
  • 模块（Modules）和 use 关键字允许你控制作用域和路径的私有性。

  • 路径（path）是一个命名例如结构体、函数或模块等项的方式

    包和 crate 用来创建库和二进制项目

  • crate 是一个二进制或库项目

  • crate 根（crate root）是一个用来描述如何构建 crate 的文件

  • 带有 Cargo.toml 文件的 包 用以描述如何构建一个或多个 crate。一个包中至多可以有一个库项目

    1. //当运行 cargo new 时是在创建一个包
    2. $ cargo new my-project
    3.    Created binary (application) `my-project` package
    4. $ ls my-project
    5. Cargo.toml
    6. src
    7. $ ls my-project/src
    8. main.rs

    Cargo 的约定配置：

  • 与 Cargo.toml 同级目录下的 src 中包含 main.rs ，默认为 crate 根，则包拥有同名二进制 crate

  • src 中包含 lib.rs 也做为 crate 根，则包带有同名的库 crate

  • 包可以带有多个二进制 crate，需将其文件置于 src/bin 目录；每个文件将是一个单独的二进制 crate

    模块系统（the module system）用来控制作用域和私有性

    微信截图_20210119141004.png

    the compiler only sees the crate module which is our main.rs file. This is because we need to explicitly(显式) build the module tree in Rust - there’s no implicit（隐式） mapping between file system tree to module tree.

  • The mod keyword declares a submodule（子模块）

  • The pub keyword makes things public
  • extern crate is like mod, but it declares an external crate dependency instead of a submodule.
  • The super keyword in module path refers to the parent scope
  • The use keyword is used to shorten(缩短) the module path
  • External dependencies(added to Cargo.toml) are globally available to all modules inside a project ```rust // main.rs mod config; mod routes; mod models;

fn main() { routes::health_route::print_health_route(); routes::user_route::print_user_route(); config::print_config(); println!(“main”); }

  1. ```rust
  2. // routes/mod.rs
  3. pub mod health_route;
  4. pub mod user_route;
  1. // routes/user_route.rs
  3. //use crate::models::user_model::print_user_model;
  4. use crate::models::user_model::print_user_model as log_user_model;
  6. pub fn print_user_route() {
  7.   crate::models::user_model::print_user_model();
  9.   //print_user_model();
  10.   log_user_model();
  12.   crate::routes::health_route::print_health_route();
  13.   // can also be called using
  14.   super::health_route::print_health_route();
  16.   println!("user_route");
  17. }
  1. // models/mod.rs
  2. pub mod user_model;
  1. // models/user_model.rs
  3. // 引用外部依赖
  4. use rand::random;
  6. pub fn print_user_model() {
  7.   let random_number: u8 = random();
  8.   println!("{}", random_number);
  9.   println!("user_model");
  10. }

集合（Collections）

集合指向的数据是储存在堆上的，这意味着数据的数量不必在编译时就已知并且可以随着程序的运行增长或缩小

vector(矢量)

vector 允许我们在一个单独的数据结构中储存多于一个的值，它在内存中彼此相邻地排列所有的值。vector 只能储存相同类型的值。

creating new vector

  • call the Vec::new function with the specified datatype

  • using the vec! macro(宏). The macro will create a new vector which holds the given initial values.

    1. fn main() {
    2.   let mut data: Vec<i32> = Vec::new();
    3.   let mut datas = vec![5, 10, 15];
    4.   let mut dataTwo = vec![5;10];
    5. }

    add Items

  • using the push method

    1. fn main() {
    2.   let mut data = Vec::new();  // Create a mutable empty vector
    4.   data.push(5);   // adding values dynamically
    5.   data.push(10);
    6. }

    access Items

    1. fn main() {
    2.   let mut v = vec![5, 10, 15];
    4.   let one: &i32 = &v[0];
    5.   println!("one = {}", one);
    6.   println!("one = {}", *one);
    8.   //(2)推荐的方法
    9.   match v.get(3) {
    10.       Some(value) => println!("value = {}", value),
    11.       _ => println!("None"),
    12.   }
    13. }

    change item value

    1. fn main() {
    2.   let mut data = vec![5, 10, 15];
    4.   data[0] = 15;
    5.   println!("{}", &data[0]); // Output 15
    6. }

    remove item

    1. fn main() {
    2.   let mut data = vec![5, 10, 15];
    3.   data.remove(0);  // 5 removed
    4.   //The pop() method removes the last item from a vector
    5.   data.pop();
    6.      //The clear() method removes all values from a vector
    7.   data.clear();
    8.   println!("{}", data.len()); // 0
    9. }

    遍历

    ```rust let mut v2: Vec = Vec::new(); v2.push(1); v2.push(2); v2.push(3);

    //6 //(1)不可变的遍历 for i in &v2 {

    1.   println!("i = {}", i);

    }

    //(2)可变的遍历 for i in &mut v2 {

    1.   *i += 1;
    2.   println!("i = {}", i);

    }

  1. <a name="k8LzI"></a>
  2. ## 字符串（String）
  3. > 可增长的、可变的、有所有权的、UTF-8 编码的字符串类型
  5. <a name="77j9k"></a>
  6. ### 创建
  8. - 以 `new` 函数创建字符串开始
  9. - 使用 `to_string` 方法
  10. - 使用 `String::from` 函数
  11. ```rust
  12. let mut s = String::new();
  14. let data = "initial contents";
  16. let s = data.to_string();
  18. // 该方法也可直接用于字符串字面值：
  19. let s = "initial contents".to_string();
  21. let s = String::from("initial contents");

更新

使用 push_str 和 push 附加字符串

  1. let mut s = String::from("foo");
  2. s.push_str("bar");
  4. let mut s = String::from("lo");
  5. s.push('l');

使用 + 运算符或 format! 宏拼接字符串

  1. let s1 = String::from("Hello, ");
  2. let s2 = String::from("world!");
  3. // 这个语句会获取 s1 的所有权，附加上从 s2 中拷贝的内容，并返回结果的所有权
  4. let s3 = s1 + &s2; // 注意 s1 被移动了，不能继续使用
  6. let s1 = String::from("tic");
  7. let s2 = String::from("tac");
  8. let s3 = String::from("toe");
  9. // 不会获取任何参数的所有权
  10. let s = format!("{}-{}-{}", s1, s2, s3);

Hash Maps

HashMap<K, V> 类型储存了一个键类型 K 对应一个值类型 V 的映射 所有的键必须是相同类型，值也必须都是相同类型

新建

  • 使用标准库中集合部分的 HashMap。
  • 在两个 vector 中，使用 zip 方法来创建一个元组的 vector，接着使用 collect 方法将这个元组 vector 转换成一个 HashMap ```rust 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”); // 通过 get 方法并提供对应的键来从哈希 map 中获取值 let score = scores.get(&team_name);

for (key, value) in &scores { println!(“{}: {}”, key, value); }

  1. ```rust
  2. use std::collections::HashMap;
  4. let teams  = vec![String::from("Blue"), String::from("Yellow")];
  5. let initial_scores = vec![10, 50];
  7. // HashMap<_, _> 类型注解是必要的
  8. // 可以使用下划线占位，而 Rust 能够根据 vector 中数据的类型推断出 HashMap 所包含的类型。
  9. let scores: HashMap<_, _> = teams.iter().zip(initial_scores.iter()).collect();
  11. let k = String::from("Blue");
  12. if let Some(v) = scores.get(&k) { //get 返回的是一个Option
  13.     println!("v = {}", v);
  14. }
  16. let k = String::from("Yellow");
  17. let v = scores.get(&k);
  18. match v {
  19.     Some(value) => println!("v = {}", value),
  20.     None => println!("None"),
  21. }

更新

覆盖

  1. use std::collections::HashMap;
  3. let mut scores = HashMap::new();
  5. scores.insert(String::from("Blue"), 10);
  6. scores.insert(String::from("Blue"), 25);
  8. println!("{:?}", scores);

只在键没有对应值时插入

  1. use std::collections::HashMap;
  3. let mut scores = HashMap::new();
  4. scores.insert(String::from("Blue"), 10);
  6. scores.entry(String::from("Yellow")).or_insert(50);
  7. scores.entry(String::from("Blue")).or_insert(50);
  9. println!("{:?}", scores);

是否存在

  1. if map.contains_key(&nums[i]) {}
  4. temp = match map.get(&nums[i]) {
  5.     Some(&x) => {
  6.         2
  7.     },
  8.     None => {
  9.         map.insert(&nums[i], 1);
  10.         1
  11.     }
  12. };

错误处理（Error Handling）

panic! 与不可恢复(unrecoverable)的错误

当执行panic! 这个宏时，程序会打印出一个错误信息，展开并清理栈数据，然后接着退出

Result 与可恢复(recoverable)的错误

使用 Result 类型来处理潜在的错误

  1. enum Result<T, E> {
  2.     Ok(T),
  3.     Err(E),
  4. }
  1. use std::fs::File;
  3. fn main() {
  4.     let f = File::open("hello.txt");
  6.     let f = match f {
  7.         Ok(file) => file,
  8.         Err(error) => {
  9.             panic!("There was a problem opening the file: {:?}", error)
  10.         },
  11.     };
  12. }

匹配不同的错误

  1. use std::fs::File;
  2. use std::io::ErrorKind;
  4. fn main() {
  5.     let f = File::open("hello.txt");
  7.     let f = match f {
  8.         Ok(file) => file,
  9.         Err(error) => match error.kind() {
  10.             ErrorKind::NotFound => match File::create("hello.txt") {
  11.                 Ok(fc) => fc,
  12.                 Err(e) => panic!("Tried to create file but there was a problem: {:?}", e),
  13.             },
  14.             other_error => panic!("There was a problem opening the file: {:?}", other_error),
  15.         },
  16.     };
  17. }
  1. use std::fs::File;
  2. use std::io::ErrorKind;
  4. fn main() {
  5.     let f = File::open("hello.txt").map_err(|error| {
  6.         if error.kind() == ErrorKind::NotFound {
  7.             File::create("hello.txt").unwrap_or_else(|error| {
  8.                 panic!("Tried to create file but there was a problem: {:?}", error);
  9.             })
  10.         } else {
  11.             panic!("There was a problem opening the file: {:?}", error);
  12.         }
  13.     });
  14. }

unwrap 和 expect

如果 Result 值是成员 Ok，unwrap 会返回 Ok 中的值。如果 Result 是成员 Err，unwrap 会为我们调用 panic!。

  1. use std::fs::File;
  3. fn main() {
  4.     let f = File::open("hello.txt").unwrap();
  5. }

expect 与 unwrap 的使用方式一样：返回文件句柄或调用 panic! 宏。expect 用来调用 panic! 的错误信息将会作为参数传递给 expect ，而不像 unwrap 那样使用默认的 panic! 信息。

  1. use std::fs::File;
  3. fn main() {
  4.     let f = File::open("hello.txt").expect("Failed to open hello.txt");
  5. }

A shortcut(快捷方式) for Propagating(传播的) Errors: the ? Operator

The ? operator can be used in functions that have a return type of Result, because it is defined to work in the same way as the match expression. The part of the match that requires a return type of Result is return Err(e), so the return type of the function has to be a Result to be compatible with this return.

  1. use std::io;
  2. use std::io::Read;
  3. use std::fs::File;
  5. fn read_username_from_file() -> Result<String, io::Error> {
  6.     let mut s = String::new();
  8.     // 使用 ? 如果没有报错继续向下执行，报错直接返回错误
  9.     File::open("hello.txt")?.read_to_string(&mut s)?;
  11.     Ok(s)
  12. }

泛型(Generic types)、traits 与生命周期(lifetimes)

泛型

在函数定义中使用泛型

当使用泛型定义函数时，我们在函数签名中通常为参数和返回值指定数据类型的位置放置泛型

  1. fn swap<T>(a: T, b: T) -> (T, T) {
  2.     (b, a)
  3. }
  5. fn main() {
  6.     println!("{:?}", swap(5.0f64, 7.5f64));
  7.     println!("{:?}", swap("One", "Two"));
  8. }

在结构体中使用泛型

  1. struct Point<T, U> {
  2.     x: T,
  3.     y: U,
  4. }
  6. fn main() {
  7.     let both_integer = Point { x: 5, y: 10 };
  8.     let both_float = Point { x: 1.0, y: 4.0 };
  9.     let integer_and_float = Point { x: 5, y: 4.0 };
  10. }

枚举中使用泛型

  1. enum Option<T> {
  2.     Some(T),
  3.     None,
  4. }
  6. enum Result<T, E> {
  7.     Ok(T),
  8.     Err(E),
  9. }

方法定义中的泛型

必须在 impl 后面声明 T，这样就可以在 Point<T> 上实现的方法中使用它。在 impl 之后声明泛型 T ，这样 Rust 就知道 Point 的尖括号中的类型是泛型而不是具体类型

  1. struct Point<T> {
  2.     x: T,
  3.     y: T,
  4. }
  6. impl<T> Point<T> {
  7.     fn get_x(&self) -> &T {
  8.         &self.x
  9.     }
  11.     fn get_y(&self) -> &T {
  12.         &self.y
  13.     }
  14. }
  16. struct Point2<T, U> {
  17.     x: T,
  18.     y: U,
  19. }
  21. impl<T, U> Point2<T, U> {
  22.     fn creat_point<V, W>(self, other: Point2<V, W>) -> Point2<T, W> {
  23.         Point2 {
  24.             x: self.x,
  25.             y: other.y,
  26.         }
  27.     }
  28. }
  31. fn main() {
  32.     let p = Point{x:1, y: 2};
  33.     println!("x = {}", p.get_x());
  34.     println!("y = {}", p.get_y());
  36.     let p = Point{x:1.1, y: 2.2};
  37.     println!("x = {}", p.get_x());
  38.     println!("y = {}", p.get_y());
  40.     let p1 = Point2{x: 5, y: 1.1};
  41.     let p2 = Point2{x: "hello", y: 'c'};
  42.     let p3 = p1.creat_point(p2);
  43.     println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
  44. }

trait 定义共享的行为

trait 用于定义与其它类型共享的功能，类似于其它语言中的接口。

  1. 可以通过 trait 以抽象的方式定义共享的行为
  2. 可以通过 trait bound 指定泛型是任何拥有特定行为的类型

    定义 trait

    ```rust pub trait GetInformation { fn get_name(&self) -> &String; fn get_age(&self) -> u32; }

trait SchoolName { fn get_school_name(&self) -> String { String::from(“HongXingSchool”) } }

  1. <a name="lKZdw"></a>
  2. ### 实现 trait
  3. ```rust
  4. pub struct Student {
  5.     pub name: String,
  6.     pub age: u32,
  7. }
  9. impl SchoolName for Student {}
  11. impl GetInformation for Student {
  12.     fn get_name(&self) -> &String {
  13.         &self.name
  14.     }
  16.     fn get_age(&self) -> u32 {
  17.         self.age
  18.     }
  19. }

trait 作为参数

  1. // 这个就是说传入的参数必须具有 GetInformation 这个trait
  2. fn print_information(item: impl GetInformation) {
  3.     println!("name = {}", item.get_name());
  4.     println!("age = {}", item.get_age());
  5. }

trait_bound

  1. trait GetName {
  2.     fn get_name(&self) -> &String;
  3. }
  5. trait GetAge {
  6.     fn get_age(&self) -> u32;
  7. }
  9. ////写法一：
  10. //fn print_information<T: GetName+GetAge>(item: T){ //使用trait bound的写法
  11. //    println!("name = {}", item.get_name());
  12. //    println!("age = {}", item.get_age());
  13. //}
  15. //写法二：
  16. fn print_information<T>(item: T)
  17.     where T: GetName+GetAge
  18. { //使用trait bound的写法
  19.     println!("name = {}", item.get_name());
  20.     println!("age = {}", item.get_age());
  21. }
  1. pub struct Student {
  2.     pub name: String,
  3.     pub age: u32,
  4. }
  6. impl GetName for Student {
  7.     fn get_name(&self) -> &String {
  8.         &self.name
  9.     }
  10. }
  12. impl GetAge for Student {
  13.     fn get_age(&self) -> u32 {
  14.         self.age
  15.     }
  16. }
  18. fn main() {
  19.     let s = Student{name: "xiaoming".to_string(), age: 10};
  20.     print_information(s);
  21. }

对任何实现了特定trait的类型有条件的实现trait

  1. trait GetName {
  2.     fn get_name(&self) -> &String;
  3. }
  5. trait PrintName {
  6.     fn print_name(&self);
  7. }
  9. impl<T: GetName> PrintName for T {
  10.     fn print_name(&self) {
  11.         println!("name = {}", self.get_name());
  12.     }
  13. }
  15. struct Student {
  16.     name: String,
  17. }
  19. impl GetName for Student {
  20.     fn get_name(&self) -> &String {
  21.         &(self.name)
  22.     }
  23. }
  25. fn main() {
  26.     let s = Student{name: String::from("xiaohuang")};
  27.     s.print_name();
  28.     println!("Hello, world!");
  29. }

生命周期

引用保持有效的作用域

  1. Rust中每一个引用都有其生命周期，也就是引用保持有效的作用域。大部分时候生命周期是隐含并可以推断的，正如大部分时候类型可以推断一样。
  2. 生命周期的主要目标是避免悬垂引用
  3. Rust编译器使用借用检查器来检查生命周期是否有效
    1. fn main() {
    2.  ////错误例子1
    3.  //let r;                       //---------------------------+------------'a
    4.  //{                            //                           +
    5.  //    let x = 5;               //-------+------'b           |
    6.  //    r = &x;                  //       |                   |
    7.  //}                            //-------+                   |
    8.  //println!("r = {}", r);       //                           |
    9.  //                             //                           |
    10.  //println!("Hello, world!");   //                           |
    11.  //                             //---------------------------+
    12.  //
    13.  let r;                       //---------------------------+------------'a
    14.                               //                           +
    15.  let x = 5;                   //-------+------'b           |
    16.  r = &x;                      //       |                   |
    17.                               //       |                   |
    18.  println!("r = {}", r);       //       |                   |
    19.                               //       |                   |
    20.  println!("Hello, world!");   //       |                   |
    21. }

    生命周期注解

    生命周期注解描述了多个引用生命周期相互的关系，而不影响其生命周期

  1. &i32        // 引用
  2. &'a i32     // 带有显式生命周期的引用
  3. &'a mut i32 // 带有显式生命周期的可变引用

函数中的生命周期

通过生命周期参数告诉 Rust 的是： longest 函数返回的引用的生命周期应该与传入参数的生命周期中较短那个保持一致

  1. fn longest<'c>(x: &'c str, y: &'c str) -> &'c str {
  2.     if x.len() > y.len() {
  3.         x
  4.     } else {
  5.         y
  6.     }
  7. }
  9. fn get_str<'a>(x: &'a str, y: &str) -> &'a str {
  10.     x
  11. }
  13. fn main() {
  14.     let s1 = String::from("abcde");
  15.     let s2 = String::from("ab");
  16.     let r = longest(s1.as_str(), s2.as_str());
  17.     println!("r = {}", r);
  19.     let ss = get_str(s1.as_str(), s2.as_str());
  21.     println!("Hello, world!");
  22. }

结构体定义中的生命周期

结构体实例的不能比里面字段数据存在得更久

生命周期省略（Lifetime Elision）

（1）没有生命周期注解却能够编译，原因：早期的rust中必须显式的声明生命周期，后来rust团队将很明确的模式进行了注解的简化。
（2）遵守生命周期省略规则的情况下能明确变量的声明周期，则无需明确指定生命周期。函数或者方法的参数的生命周期称为输入生命周期，而返回值的生命周期称为输出生命周期。
（3）编译器采用三条规则判断引用何时不需要生命周期注解，当编译器检查完这三条规则后仍然不能计算出引用的生命周期，则会停止并生成错误。
（4）生命周期注解省略规则适用于fn定义以及impl块定义，如下：
a、每个引用的参数都有它自己的生命周期参数。例如如下：
一个引用参数的函数，其中有一个生命周期： fn foo<’a>(x: &’a i32)
两个引用参数的函数，则有两个生命周期 ：fn foo<’a, ‘b>(x: &’a i32, y: &’b i32)
以此类推。
b、如果只有一个输入生命周期参数，那么它被赋予所有输出生命周期参数：
fn foo(x: &i32) -> &i32 等价于 fn foo<’a>(x: &’a i32) -> &’a i32
c、如果方法有多个输入生命周期参数，不过其中之一因为方法的缘故为&self或者&mut self，那么self的生命周期被赋予所有输出生命周期参数。例子在下面来看。
fn function(&self, x: &str, y: &str, ….) -> &str 

  1. #[derive(Debug)]
  2. struct A<'a> {
  3.     name: &'a str,
  4. }
  6. fn main() {
  7.     let n = String::from("hello");
  8.     let a = A{name: &n};
  9.     println!("a = {:#?}", a);
  11.     println!("Hello, world!");
  12.     let s = get_a_str(&n);
  13.     println!("s = {}", s);
  14. }
  16. //2、生命周期省略
  17. fn get_a_str(s: &str) -> &str {
  18.     s
  19. }

方法定义中的生命周期注解

  1. struct StuA<'a> {
  2.     name: &'a str,
  3. }
  5. impl<'b> StuA<'b> {
  6.     fn do_something(&self) -> i32 {
  7.         3
  8.     }
  10.     fn do_something2(&self, s: &str) -> &str{
  11.     //fn do_something2<'b>(&'b self, s: &str) -> &'b str{
  12.         self.name
  13.     }
  15.     fn do_something3<'a>(&self, s: &'a str) -> &'a str{
  16.         s
  17.     }
  18. }
  20. fn main() {
  21.     let s = String::from("hello");
  22.     let a = StuA{name: &s};
  23.     println!("{}", a.do_something());
  24.     let s2 = String::from("hello");
  25.     println!("{}", a.do_something2(&s2));
  27.     println!("{}", a.do_something3(&s2));
  28.     println!("Hello, world!");
  29. }

测试（writing automated tests）

  1. 设置任何所需的数据或状态
  2. 运行需要测试的代码
  3. 断言其结果是我们所期望的

    编写测试

    使用 #[test] 属性标明哪些函数是测试。 当使用 cargo test 命令运行测试时，Rust 会构建一个测试执行程序用来调用标记了 test 属性的函数，并报告每一个测试是通过还是失败。

  1. # fn main() {}
  2. # 测试模块的 #[cfg(test)] 注解告诉 Rust 只在执行 cargo test 时才编译和运行测试代码，
  3. # 而在运行 cargo build 时不这么做
  4. #[cfg(test)]
  5. mod tests {
  6.     #[test]
  7.     fn it_works() {
  8.         assert_eq!(2 + 2, 4);
  9.     }
  10. }

使用 assert! 宏来检查结果

  1. # fn main() {}
  2. #[cfg(test)]
  3. mod tests {
  4.     use super::*;
  6.     #[test]
  7.     fn larger_can_hold_smaller() {
  8.         let larger = Rectangle { length: 8, width: 7 };
  9.         let smaller = Rectangle { length: 5, width: 1 };
  11.         assert!(larger.can_hold(&smaller));
  12.     }
  13. }

使用 assert_eq! 和 assert_ne! 宏来测试相等

  • assert_eq!：比较相等
  • assert_ne!：比较不相等

    使用 should_panic 检查 panic

    这个属性在函数中的代码 panic 时会通过，而在其中的代码没有 panic 时失败。 可以给 should_panic 属性增加一个可选的 expected 参数。测试工具会确保错误信息中包含其提供的文本

  1. # fn main() {}
  2. # pub struct Guess {
  3. #     value: i32,
  4. # }
  5. #
  6. // --snip--
  8. impl Guess {
  9.     pub fn new(value: i32) -> Guess {
  10.         if value < 1 {
  11.             panic!("Guess value must be greater than or equal to 1, got {}.",
  12.                    value);
  13.         } else if value > 100 {
  14.             panic!("Guess value must be less than or equal to 100, got {}.",
  15.                    value);
  16.         }
  18.         Guess {
  19.             value
  20.         }
  21.     }
  22. }
  24. #[cfg(test)]
  25. mod tests {
  26.     use super::*;
  28.     #[test]
  29.     #[should_panic(expected = "Guess value must be less than or equal to 100")]
  30.     fn greater_than_100() {
  31.         Guess::new(200);
  32.     }
  33. }

迭代器（Iterators）与闭包（Closures）

闭包

闭包是可以保存进变量或者作为参数传递给其它函数的匿名函数。闭包和函数不同的是，闭包允许捕获调用者作用域中的值。 闭包的定义以一对竖线（|）开始，在竖线中指定闭包的参数； 如果有多于一个参数，可以使用逗号分隔，比如 |param1, param2|。

  1. fn main() {
  2.     let use_closure = || {
  3.         println!("This is a closure");
  4.     };
  5.     use_closure();
  6.     println!("Hello, world!");
  8.     //闭包定义会为每个参数和返回值类型推导一个具体的类型，但是不能推导两次
  9.     let add_one_v2 = |x: u32| -> u32 { x + 1 };
  10.     let add_one_v3 = |x| {x + 1};
  11.     let add_one_v4 = |x| x+1;
  13.     let a = add_one_v1(5);//use function
  14.     let b = add_one_v2(5);
  15.     let c = add_one_v3(5);
  16.     let d = add_one_v4(5);
  17.     println!("a = {}, b = {}, c = {}, d = {}", a, b, c, d);
  19.     //不能推导两次的例子
  20.     let example_closure = |x| x;
  21.     let s = example_closure(String::from("hello"));
  22.     println!("s = {}", s);
  24.     //let n = example_closure(5);
  25.     let n = example_closure(5.to_string());
  26.     println!("n = {}", n);
  28.     //捕捉环境中的变量
  29.     let i = 1;
  30.     let exe = |x| {x+i};
  31.     let r = exe(5);
  32.     println!("r = {}", r);
  33. }
  35. //语法格式
  36. fn add_one_v1(x: u32) -> u32 {
  37.     x + 1
  38. }

捕获环境中的变量

闭包可以通过三种方式捕获其环境，它们对应函数的三种获取参数的方式，分别是获取所有权、可变借用、不可变借用。

  1. FnOnce消费从周围作用域捕获的变量，闭包周围的作用域被称为其环境。为了消费捕获到的变量，闭包必须获取其所有权并在定义闭包时将其移进闭包。其名称的Once部分代表了闭包不能多次获取相同变量的所有权。
  2. FnMut获取可变的借用值，所以可以改变其环境
  3. Fn从其环境获取不可变的借用值。

当创建一个闭包时，rust会根据其如何使用环境中的变量来推断我们希望如何引用环境。由于所有闭包都可以被调用至少一次，因此所有闭包都实现了FnOnce。没有移动被捕获变量的所有权到闭包的闭包也实现了FnMut，而不需要对捕获的变量进行可变访问的闭包实现了Fn。

  1. fn main() {
  2.     //let x = 4;
  3.     //let equal_to_x = |z| z==x;
  4.     //let y = 4;
  5.     //assert!(equal_to_x(y));
  7.     let x = vec![1, 2, 3];
  8.     // 将 x 的所有权移入闭包中，后续不能使用 
  9.     let equal_to_x = move |z| {z==x};
  10.     println!("x === {:?}", x);
  12.     let y = vec![1, 2, 3];
  13.     assert!(equal_to_x(y));
  14. }

迭代器（iterator）

  1. 迭代器负责遍历序列中的每一项和决定序列何时结束的逻辑。
  2. 创建迭代器：迭代器是惰性的，意思就是在调用方法使用迭代器之前，不会有任何效果
  3. 每个迭代器都实现了iterator trait, iterator trait定义在标准库中 ```rust //trait Iterator { // type Item; // fn next(mut self) -> Option; //type Item和Self::Item这种用法叫做定义trait的关联类型 //} ////next是Iterator被要求实现的唯一的一个方法，next一次返回一个元素，当迭代器结束时候，返回None

fn main() { let v1 = vec![1, 2, 3]; let mut v1_iter = v1.iter(); //到目前为止，不会对v1产生任何影响 //for val in v1_iter { // println!(“val = {}”, val); //} if let Some(v) = v1_iter.next() { println!(“v = {}”, v);//1 } if let Some(v) = v1_iter.next() { println!(“v = {}”, v);//2 } if let Some(v) = v1_iter.next() { println!(“v = {}”, v);//3 } if let Some(v) = v1_iter.next() { println!(“v = {}”, v); } else { println!(“At end”); }

  1. //-----迭代可变引用-----
  2. let mut v2 = vec![1, 2, 3];
  3. let mut v2_iter = v2.iter_mut();
  4. if let Some(v) = v2_iter.next() {
  5.     *v = 3;
  6. }
  7. println!("v2 = {:?}", v2);
  9. //-----消费适配器------
  10. let v1 = vec![1, 2, 3];
  11. let v1_iter = v1.iter();
  12. let total: i32 = v1_iter.sum();//调用消费适配器sum来求和
  13. println!("total = {}", total);
  15. //-----迭代适配器------
  16. println!("++++++++++++");
  17. let v1 = vec![1, 2, 3];
  18. println!("v1 = {:?}", v1);
  20. let v2: Vec<_> = v1.iter().map(|x| x+1).collect();
  21. println!("v2 = {:?}", v2);
  23. //------------------------
  24. println!("++++++++++++");
  25. let v1 = vec![1, 12, 3, 45];
  26. println!("v1 = {:?}", v1);
  28. let v2: Vec<_> = v1.into_iter().filter(|x| *x > 5).collect();
  29. println!("v2 = {:?}", v2);
  31. println!("Hello, world!");

}

  1. <a name="4Djcx"></a>
  2. # 智能指针（smart pointer）
  4. 1. 智能指针是一类数据结构，类似于指针，但拥有额外的元数据。特别是拥有一个引用计数（记录智能指针总共有多少个所有者，并且当没有所有者时清除数据）。
  5.    1. 普通引用和智能指针的一个额外区别：引用只是借用数据的指针，而智能指针则是拥有他们指向的数据
  6. 2. 智能指针通常使用结构体实现。区别于常规结构体的特征在于其实现了 Deref 和 Drop trait
  7.    1. Deref trait 允许智能指针结构体实例表现得像引用一样，这样可以编写既用于引用，又用于智能指针的代码
  8.    1. Drop trait 允许自定义当智能指针离开作用域时执行的代码
  9. 3. 几个标准库中的智能指针
  10.    1. Box<T>，用于在堆上分配
  11.    1. Rc<T>，一个引用计数类型，其数据可以有多个所有者
  12.    1. Ref<T> 和 RefMut<T>，通过 RefCell<T>访问，一个在运行时而不是在编译时执行借用规则的类型
  14. <a name="tlGmm"></a>
  15. ## Box<T>
  17. 1. 使用 Box<T>  将数据存储在堆上，当 Box 超出范围时，将调用析构函数销毁所有内存对象并释放内存
  18. 1. Box 适用场景
  19.    1. 递归类型和 trait 对象，Rust 需要在编译时知道一个类型占用多少空间，Box<T> 的大小是已知的
  20.    1. “大”的数据转移所有权，用 Box<T> 只需拷贝指针
  21. <a name="tWDJW"></a>
  22. ### 使用 Box<T> 将数据存储在堆上
  23. ```rust
  24. fn main()
  25. {
  26.   let a = Box :: new(1);
  27.   print!("value of a is : {}", a);
  28. }

微信截图_20210217101459.png

Box 在递归类型中的使用

  1. use List::{Cons, Nil};
  3. #[derive(Debug)]
  4. enum List<T> {
  5.     Cons(T, Box<List<T>>),
  6.     Nil,
  7. }
  9. fn main() {
  10.     let recursive_list: List<i32> = Cons(1, Box::new(Cons(2, Box::new(Nil))));
  11.     println!("{:?}", recursive_list); // 打印出：Cons(1, Cons(2, Nil))
  12. }

Box 在 trait 对象中的使用

Rust tries to be as explicit as possible whenever it allocates memory on the heap. So if your function returns a pointer-to-trait-on-heap in this way, you need to write the return type with the dyn keyword

  1. trait T {
  2.     fn m(&self) -> u64;
  3. }
  5. struct S {
  6.     i: u64
  7. }
  9. impl T for S {
  10.     fn m(&self) -> u64 { self.i }
  11. }
  13. fn f(x: Box<dyn T>) {
  14.     println!("{}", x.m())
  15. }
  17. fn main() {
  18.     let s = S{i : 100};
  19.     println!("{}", s.m());
  21.     let b: Box<S> = Box::new(S{i: 100});
  22.     f(b);
  23. }

Rc

默认 Rust 中，对一个资源，同一时刻，有且只有一个所有权拥有者。Rc 使用引用计数的方法，让程序在同一时刻，实现同一资源的多个所有权拥有者，多个拥有者共享资源。
Rc 用于同一线程内部，通过 use std::rc::Rc 来引入。它有以下几个特点：

  1. 用 Rc 包装起来的类型对象，是 immutable 的，即 不可变的。即你无法修改 Rc<T> 中的 T 对象，只能读；
  2. 一旦最后一个拥有者消失，则资源会被自动回收，这个生命周期是在编译期就确定下来的；
  3. Rc 只能用于同一线程内部，不能用于线程之间的对象共享（不能跨线程传递）；
  4. Rc 实际上是一个指针，它不影响包裹对象的方法调用形式（即不存在先解开包裹再调用值这一说）。 ```rust enum List { Cons(i32, Rc), Nil, }

use crate::List::{Cons, Nil}; use std::rc::Rc;

fn main() { let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil))))); println!(“count after creating a = {}”, Rc::strong_count(&a));

  1. let b = Cons(3, Rc::clone(&a));
  2. println!("count after bind to b, a count = {}", Rc::strong_count(&a));
  4. {
  5.     let c = Cons(4, Rc::clone(&a));
  6.     println!("count after bind to c, a count = {}", Rc::strong_count(&a));
  7. }
  9. println!("count at end, a = {}", Rc::strong_count(&a));
  10. println!("Hello, world!");

}

  1. <a name="tQfRI"></a>
  2. ## Cell, RefCell
  3. 提供了内部可变性<br />通常，我们要修改一个对象，必须
  5. 1. 成为它的拥有者，并且声明 `mut`；
  6. 1. 或 以 `&mut` 的形式，借用；
  8. 而通过 `Cell`, `RefCell`，我们可以在需要的时候，就可以修改里面的对象。而不受编译期静态借用规则束缚。
  9. <a name="JYhvq"></a>
  10. ### RefCell
  11. `RefCell` 实现了 `运行时借用`，这个借用是临时的。这意味着，编译器对 `RefCell` 中的内容，不会做静态借用检查。<br />`RefCell` 的特点：
  13. 1. 在不确定一个对象是否实现了 `Copy` 时，直接选 `RefCell`；
  14. 1. 如果被包裹对象，同时被可变借用了两次，则会导致线程崩溃。所以需要用户自行判断；
  15. 1. `RefCell` 只能用于线程内部，不能跨线程；
  16. 1. `RefCell` 常常与 `Rc` 配合使用（都是单线程内部使用）；
  17. - .borrow()：不可变借用被包裹值。同时可存在多个不可变借用
  18. - .borrow_mut()：可变借用被包裹值。同时只能有一个可变借用。
  19. - .into_inner()：取出包裹值。
  20. ```rust
  21. use std::collections::HashMap;
  22. use std::cell::RefCell;
  23. use std::rc::Rc;
  25. fn main() {
  26.     let shared_map: Rc<RefCell<_>> = Rc::new(RefCell::new(HashMap::new()));
  27.     shared_map.borrow_mut().insert("africa", 92388);
  28.     shared_map.borrow_mut().insert("kyoto", 11837);
  29.     shared_map.borrow_mut().insert("piccadilly", 11826);
  30.     shared_map.borrow_mut().insert("marbles", 38);
  31. }

并发编程(concurrency)

using threads(线程) to run code simultaneously(同时地)

使用 spawn 创建新线程

  1. use std::thread;
  2. use std::time::Duration;
  4. fn main() {
  5.     thread::spawn(|| {
  6.         for i in 1..10 {
  7.             println!("hi number {} from the spawned thread!", i);
  8.             //调用强制线程停止执行一小段时间，这会允许其他不同的线程运行
  9.             thread::sleep(Duration::from_millis(1));
  10.         }
  11.     });
  13.     for i in 1..5 {
  14.         println!("hi number {} from the main thread!", i);
  15.         thread::sleep(Duration::from_millis(1));
  16.     }
  17. }

使用 join 等待所有线程结束

  1. use std::thread;
  2. use std::time::Duration;
  4. fn main() {
  5.     let handle = thread::spawn(|| {
  6.         for i in 1..10 {
  7.             println!("hi number {} from the spawned thread!", i);
  8.             thread::sleep(Duration::from_millis(1));
  9.         }
  10.     });
  12.     for i in 1..5 {
  13.         println!("hi number {} from the main thread!", i);
  14.         thread::sleep(Duration::from_millis(1));
  15.     }
  17.     handle.join().unwrap();
  18. }

线程与 move 闭包

其经常与 thread::spawn 一起使用，因为它允许我们在一个线程中使用另一个线程的数据
在参数列表前使用 move 关键字强制闭包获取其使用的环境值的所有权

  1. use std::thread;
  3. fn main() {
  4.     let v = vec![1, 2, 3];
  6.     let handle = thread::spawn(move || {
  7.         println!("Here's a vector: {:?}", v);
  8.     });
  10.     handle.join().unwrap();
  11. }

using message passing(消息传递) to transfer data between threads

Do not communicate by sharing memory; instead, share memory by communicating.

Rust 中一个实现消息传递并发的主要工具是 通道（channel）

  • 发送者（transmitter）
  • 接收者（receiver） ```rust use std::thread; // 多个生产者，单个消费者（multiple producer, single consumer） use std::sync::mpsc;

fn main() { // tx 和 rx 作为 发送者（transmitter）和 接收者（receiver）的缩写 let (tx, rx) = mpsc::channel();

  1. thread::spawn(move || {
  2.     let val = String::from("hi");
  3.     // send 函数获取其参数的所有权并移动这个值归接收者所有
  4.     tx.send(val).unwrap();
  5. });
  7. // recv 方法会阻塞主线程执行直到从通道中接收一个值
  8. let received = rx.recv().unwrap();
  9. println!("Got: {}", received);

}

  1. <a name="Z2frN"></a>
  2. ### 发送多个值并观察接收者的等待
  3. ```rust
  4. use std::thread;
  5. use std::sync::mpsc;
  6. use std::time::Duration;
  8. fn main() {
  9.     let (tx, rx) = mpsc::channel();
  11.     thread::spawn(move || {
  12.         let vals = vec![
  13.             String::from("hi"),
  14.             String::from("from"),
  15.             String::from("the"),
  16.             String::from("thread"),
  17.         ];
  19.         for val in vals {
  20.             tx.send(val).unwrap();
  21.             thread::sleep(Duration::from_secs(1));
  22.         }
  23.     });
  25.     for received in rx {
  26.         println!("Got: {}", received);
  27.     }
  28. }

通过克隆发送者来创建多个生产者

  1. # use std::thread;
  2. # use std::sync::mpsc;
  3. # use std::time::Duration;
  4. #
  5. # fn main() {
  6. // --snip--
  8. let (tx, rx) = mpsc::channel();
  10. let tx1 = mpsc::Sender::clone(&tx);
  11. thread::spawn(move || {
  12.     let vals = vec![
  13.         String::from("hi"),
  14.         String::from("from"),
  15.         String::from("the"),
  16.         String::from("thread"),
  17.     ];
  19.     for val in vals {
  20.         tx1.send(val).unwrap();
  21.         thread::sleep(Duration::from_secs(1));
  22.     }
  23. });
  25. thread::spawn(move || {
  26.     let vals = vec![
  27.         String::from("more"),
  28.         String::from("messages"),
  29.         String::from("for"),
  30.         String::from("you"),
  31.     ];
  33.     for val in vals {
  34.         tx.send(val).unwrap();
  35.         thread::sleep(Duration::from_secs(1));
  36.     }
  37. });
  39. for received in rx {
  40.     println!("Got: {}", received);
  41. }
  43. // --snip--
  44. # }

shared-state

通过共享内存通讯

互斥器一次只允许一个线程访问数据

互斥器（mutex）「mutual exclusion」，任意时刻，其只允许一个线程访问某些数据。

  1. 在使用数据之前尝试获取锁
  2. 处理完被互斥器所保护的数据之后，必须解锁数据，这样其他线程才能够获取锁 ```rust use std::sync::Mutex;

fn main() { let m = Mutex::new(5);

  1. {
  2.     let mut num = m.lock().unwrap();
  3.     *num = 6;
  4.     // Mutex 是一个智能指针,离开作用域时自动释放锁
  5. }
  7. println!("m = {:?}", m);

}

  1. <a name="AOany"></a>
  2. ### 通过 Arc 实现多线程和多所有权
  3. ```rust
  4. use std::sync::{Mutex, Arc};
  5. use std::thread;
  7. fn main() {
  8.     let counter = Arc::new(Mutex::new(0));
  9.     let mut handles = vec![];
  11.     for _ in 0..10 {
  12.         let counter = Arc::clone(&counter);
  13.         let handle = thread::spawn(move || {
  14.             let mut num = counter.lock().unwrap();
  16.             *num += 1;
  17.         });
  18.         handles.push(handle);
  19.     }
  21.     for handle in handles {
  22.         handle.join().unwrap();
  23.     }
  25.     println!("Result: {}", *counter.lock().unwrap());
  26. }

资料

  1. Rust 编程语言
  2. 令狐一冲
  3. rustPrimer