【Rust基础】Rustlings答案及解析

已于 2023-04-15 20:47:31 修改
阅读量7k 收藏 31
点赞数 23
分类专栏： # Rust 文章标签： rust 开发语言 后端
于 2023-04-10 20:36:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43840665/article/details/130065993
版权

系列综述：
💞目的：本篇文章是个人通过Rustlings学习Rust过程中整理的，整理期间苛求每个知识点，平衡理解简易度与深入程度。
🥰来源：材料主要源于Rustlings进行的，每个知识点的修正和深入主要参考各平台大佬的文章，其中也可能含有少量的个人实验自证。
🤭结语：如果有帮到你的地方，就点个赞和关注一下呗，谢谢🎈🎄🌷！！！

文章目录

😊点此到文末惊喜↩︎

使用前提

  1. 配置好rust和vscode环境
  2. 进入rustlings的根目录
  3. 在命令行输入rustlings watch命令，进行自动检测编译模式
  4. 按照rustlings环境下命令进行顺序编写，编写完成后删除// I AM NOT DONE
  5. 每次运行rustlings会进行重新编译，并分析进度和给出错误提示

Intro

Intro.1

  1. 答案：啥也不用改，直接删除// I AM NOT DONE即可
  2. 知识点
    • 打印宏
    // 打印函数
println!("Hello world");

Intro.2

  1. 答案

    println!("Hello {}!", "World");

  2. 知识点

    • println!是一个宏
    • 占位符{}，会被顺序替换成相应类型的参数
    println!("{} World {} {}", "Hello", true, 42);
//输出结果:
//Hello World true 42

let origin = Point { x: 10, y: 20 };
println!("origin = {}", origin)
//输出结果：
//origin = (10, 20)

  3. 更多语法可见： [rust-007]rust的println!函数的各种用法

Variables

基本知识点

  1. 变量声明
    • 不可变绑定：let将值和变量名进行绑定，声明同时必须初始化
    // 不可变绑定
let x = 5;// 绑定同时必须初始化
x = 10; // error: 绑定后不能改变
// 强类型的自动推导
let x = 1.000;// 编译器会推断为f32
let x : f64 = 1.000;// 类型注解
    • 可变绑定：使用mut表示可变绑定
    // 普通的mut可变
let mut x = 5;
x = 10;
    • 重新绑定（重影）：变量名称可以被重新使用的机制
    // 变量遮蔽的继承可变
let x = 5; // warning:未使用的符号
let x = 10;// 可以通过let对同一符号名进行重新绑定
  2. 注意：
    • Rust 是强类型语言，能类型推导和进行类型安全检查
    • 声明变量最好加类型注解，没有注解Rust会进行类型推断，可能不符合预期
    • Rust处于内存安全考虑，不允许使用或捕获任何未初始化的变量
    • 位置表达式 = 值表达式，Rust没有左右值的概念，左边表达式返回内存地址，右边表达式返回值
  3. 常量
    • 常量必须加类型，因为局部的类型推断可能出现问题
    • 在编译器进行了类型检查的文本替换，占用代码段或者说不占用内存空间，运行时常量值会被内联到使用的位置
    const NUMBER:i32 = 3;
  4. 默认不可变的好处
    • 代码逻辑的干净清爽。人们总是默认使用简短的不可变语法，所以使得代码逻辑更加简单
    • 多线程编程中的参数传递。假如语法层面保证了一个值的不可变，就不需要锁保护

Variables.1

  1. 答案：声明一个变量，需要加 let，如果不声明 mut 则默认为不可变变量。
    let x = 5;
println!("x has the value {}", x);

Variables.2

    let x: i32 = 10;// 注意初始化类型
    if x == 10 {
        println!("x is ten!");
    } else {
        println!("x is not ten!");
    }

Variables.3

    let x: i32 = 100;// Rust的变量使用前必须绑定值
    println!("Number {}", x);

Variables.4

    let mut x = 3;// 可变绑定
    println!("Number {}", x);
    x = 5; // don't change this line
    println!("Number {}", x);

Variables.5

- const变量的绑定必须要有初始类型和值

const NUMBER:i32 = 3;

Variables.5

    let number = "T-H-R-E-E"; // don't change this line
    println!("Spell a Number : {}", number);
    let number = 3; // 重影方式，进行重新绑定
    println!("Number plus two is : {}", number + 2);

Functions

Functions.1

这里实际上是对于函数 call_me，有使用但是没有声明，因此我们只需要声明一下即可。

fn call_me() {

}

Functions.2

函数形参必须指定类型

fn call_me(num: i32) {
    for i in 0..num {
        println!("Ring! Call number {}", i + 1);
    }
}

Functions.3

函数形参和实参的类型和数量必须匹配

    call_me(10);

Functions.4

函数返回值使用->进行标识

fn sale_price(price: i32) -> i32{
    if is_even(price) {
        price - 10
    } else {
        price - 3
    }
}

Functions.5

函数的返回值后不需要加分号

fn square(num: i32) -> i32 {
    num * num
}

if

if.1

Rust 的 If statement 部分并不需要加括号

pub fn bigger(a: i32, b: i32) -> i32 {
    // Complete this function to return the bigger number!
    // Do not use:
    // - another function call
    // - additional variables
    if a > b {
        a
    } else {
        b
    }
}

If.2

这个需要根据下面的测试程序决定没一个输入应该输出什么字符串。

pub fn foo_if_fizz(fizzish: &str) -> &str {
    if fizzish == "fizz" {
        "foo"
    } else if fizzish == "fuzz" {
        "bar"
    } else {
        "baz"
    }
}

Quiz1

这个小测试实际上需要我们读懂上面的英文含义，并实现calculate_price_of_apples函数。
按照所叙述的要求，当购买数量超过 40 时，每个苹果 1 元，否则 2 元。

fn calculate_price_of_apples(cnt: i32) -> i32 {
    if cnt <= 40 {
        cnt << 1
    } else {
        cnt
    }
}

Primitive_types

Primitive_types.1

可以发现下面的变量 is_evening 有使用没有定义，再考虑到这里代码的语义，可以得到需要填写的代码：

let is_evening = false; // Finish the rest of this line like the example! Or make it be false!

Primitive_types.2

只需要对于 your_character 这个变量进行定义即可

let your_character = '3';

Primitive_types.3

定义一个字符串数组，数组里面每一个元素均为 “qaq”，数组总长度为 666.

let a = ["qaq"; 666];

Primitive_types.4

切片的变量实际上并不能获得地址的所有权的，仅仅是一个引用

    let nice_slice = &a[1..4];// 前闭后开

Primitive_types.5

元组的使用

let (name, age) = cat;

Primitive_types.4

获得元组的某一个元素，就直接使用[元组名.index]这样的格式即可。

let numbers = (1, 2, 3);
 // Replace below ??? with the tuple indexing syntax.
 let second = numbers.1;// 元素的下标引用
 assert_eq!(2, second,
     "This is not the 2nd number in the tuple!")

Vecs

Vecs1

使用宏 vec! 来定义一个 vector

fn array_and_vec() -> ([i32; 4], Vec<i32>) {
    let a = [10, 20, 30, 40]; // a plain array
    let v = vec![10, 20, 30, 40];// TODO: declare your vector here with the macro for vectors
    (a, v)
}

Vecs2

  1. 遍历改变 vector 内部元素的方式
    • 迭代器遍历元素
    fn vec_loop(mut v: Vec<i32>) -> Vec<i32> {
   for i in v.iter_mut() {
       // TODO: Fill this up so that each element in the Vec `v` is
       // multiplied by 2.
       *i <<= 1;
   }

   // At this point, `v` should be equal to [4, 8, 12, 16, 20].
   v
}
    • map 映射：使用匿名函数进行变量的捕获和运算
    fn vec_map(v: &Vec<i32>) -> Vec<i32> {
    v.iter().map(|num| {
        // TODO: Do the same thing as above - but instead of mutating the
        // Vec, you can just return the new number!
        num << 1
    }).collect()
}

Move_semantics移动语义

基本知识

  1. 所有权规则
    • Rust 中的每个值都有一个变量，称为其所有者。
    • 每个值只能有一个所有者，但可以有多个借用者
    • 值所有者的生命周期只在可用范围内，在生命范围结束时，编译器自动调用函数释放资源
  2. 变量生命范围
    {
    // 在声明以前，变量 s 无效
    let s = "runoob";
    // 这里是变量 s 的可用范围
}
// 变量范围已经结束，变量 s 无效
  3. 值传递类型
    • 移动语义Move：
      • 引用类型：栈中的指针变量指向堆内存，赋值时使用移动语义，赋值后原指针失效。
    let s1 = String::from("hello");
let s2 = s1;
// 赋值后s1失效，指向的堆内存所有权移动给s2
    • 拷贝语义Clone：
      • 基本数据类型存在栈中，直接赋值时拷贝语义
    let x = 5;
let y = x;
// 拷贝语义：赋值后均有效

// 堆内存的深拷贝
let s1 = String::from("hello");
let s2 = s1.clone();
  4. 函数参数所有权的传递
    • 在栈中的基本数据类型的赋值是拷贝语义，在堆中的引用数据类型的赋值是移动语义
    • 函数返回值的临时变量可以通过移动语义返回到函数调用处
    fn main() {
    let s = String::from("hello");
    // s 被声明有效

    takes_ownership(s);
    // s 的值被当作参数传入函数
    // 所以可以当作 s 已经被移动，从这里开始已经无效

    let x = 5;
    // x 被声明有效

    makes_copy(x);
    // x 的值被当作参数传入函数
    // 但 x 是基本类型，依然有效
    // 在这里依然可以使用 x 却不能使用 s
    let s2 = String::from("hello");
	let s3 = takes_and_gives_back(s2);
	// s2 被当作参数移动, s3 获得返回值所有权
} // 函数结束, x 无效, 然后是 s. 但 s 已被移动, 所以不用被释放

fn takes_ownership(some_string: String) {
    // 一个 String 参数 some_string 传入，有效
    println!("{}", some_string);
} // 函数结束, 参数 some_string 在这里释放

fn makes_copy(some_integer: i32) {
    // 一个 i32 参数 some_integer 传入，有效
    println!("{}", some_integer);
} // 函数结束, 参数 some_integer 是基本类型, 无需释放
fn take_and_giveback(a_string:String)->String{
	a_string  // a_string 被当作返回值移出函数
}
  5. 引用
    • 引用是一个指向被引用对象的指针变量，是一种间接访问的方式
    • 引用不会获得值的所有权，引用只能租借（Borrow）值的所有权。
    • 如果被引用对象的所有权发生转移，需要重新租借
    • 不能多重可变引用，为了防止写时碰撞
    • Rust不允许返回局部变量的引用
    // 基本引用
let s1 = String::from("hello");
let s2 = &s1;
// 所有权转移引起的租借失效
let s1 = String::from("hello");
let mut s2 = &s1;
let s3 = s1;// s1内存资源所有权转移到s3中，s2的租借失效
s2 = &s3; // 重新从 s3 租借所有权
// 可变租借
let mut s1 = String::from("run");// 被租借对象本身就是可变的
// s1 是可变的
let s2 = &mut s1;// 赋予租借者可变的权力
// s2 是可变的引用
let s3 = &mut s1;// error，不允许多重可变引用

在这里插入图片描述

Move_semantics1

vec1 在 11 行进行了修改，而我们在进行变量声明的时候并没有使用 mut 关键字，因此出现错误

let mut vec1 = fill_vec(vec0);

Move_semantics2

vec0 在进入函数之后，所有权就被传入进去并在函数结束后释放。因此在 fill_vec 之后就再也不能调用 vec0 了。这里解决的方式是通过 clone 的方式进行深拷贝，避免直接使用变量本身。

let vec0 = Vec::new();
let vec = vec0.clone();
let mut vec1 = fill_vec(vec);

Move_semantics3

问题的核心错误在于函数 fill_vec 的 vec 变量是不可变变量

fn fill_vec(mut vec: Vec<i32>) -> Vec<i32> {
    vec.push(22);
    vec.push(44);
    vec.push(66);

    vec
}

Move_semantics4

问题：函数调用形参未写，并且局部变量名称相同

fn fill_vec(vec0: Vec<i32>) -> Vec<i32> {
    let mut vec = vec0;

Move_semantics5

Rust1.31以后，借用的作用域的结束位置从花括号{}变成最后一次使用的位置

fn main() {
    let mut x = 100;
    let y = &mut x;
    *y += 100;// 最后一次使用y，使用完成后会自动释放
    let z = &mut x;
    *z += 1000;
    assert_eq!(x, 1200);
}

Move_semantics6

注释提示了，第一个函数不应该有所有权，第二个函数应该获得所有权。
所以第一个函数使用借用，第二个函数使用移动语义进行直接传递

fn main() {
    let data = "Rust is great!".to_string();

    get_char(&data);

    string_uppercase(data);
}

// Should not take ownership
fn get_char(data: &String) -> char {// 形参借用也要加&
    data.chars().last().unwrap()
}

// Should take ownership
fn string_uppercase(mut data: String) {
    data = data.to_uppercase();

    println!("{}", data);
}

Structs

Structs1

  1. 每一个// TODO: 都需要改动
// 结构的声明方式
struct ColorClassicStruct {
    // TODO: Something goes here
    red: i32,
    green: i32,
    blue: i32,
}
// 元组的声明方式
struct ColorTupleStruct(u8, u8, u8);
// 结构体的初始化及绑定
// TODO: Instantiate a classic c struct!
// let green =
 let green = ColorClassicStruct {
     red: 0,
     green: 255,
     blue: 0,
 };
// 元组的初始化及绑带
let green = ColorTupleStruct(0, 255, 0);
// 实例化一个单元类
let unit_like_struct = UnitLikeStruct;

Structs2

按照断言补足即可

let your_order = Order {
            name: String::from("Hacker in Rust"),
            year: 2019,
            made_by_phone: false,
            made_by_mobile: false,
            made_by_email: true,
            item_number: 123,
            count: 1,
        };

Structs3

通过断言必须为真，分析代码逻辑，从而改写函数。

fn is_international(&self) -> bool {
    // Something goes here...
    self.sender_country != self.recipient_country
}

fn get_fees(&self, cents_per_gram: i32) -> i32 {
    // Something goes here...
    self.weight_in_grams * cents_per_gram
}

Enums

Enums1

枚举类写法

enum Message {
    // TODO: define a few types of messages as used below
    Quit,
    Echo,
    Move,
    ChangeColor,
}

Enums2

在枚举类内可以定义不同类型的元素，甚至还可以定义枚举类。

enum Message {
    // TODO: define the different variants used below
    Move {x: i32, y: i32},
    Echo(String),
    ChangeColor(i32, i32, i32),
    Quit
}

Enums3

match函数和枚举的使用，match类似switch但是不需要break

// 枚举类
enum Message {
    // TODO: implement the message variant types based on their usage below
    ChangeColor((u8, u8, u8)),
    Echo(String),
    Move(Point),
    Quit,
}
// match函数
match message{
    Message::ChangeColor(t)         =>  self.change_color(t),
    Message::Echo(msg)              => self.echo(msg),
    Message::Move(point)            => self.move_position(point),
    Message::Quit                   => self.quit(), 
};
// 括号？
state.process(Message::ChangeColor((255, 0, 255)));

strings

切片相关知识

  1. String对象
    • 内存结构：存储在栈上，大小固定为三个字。
      • 一个指向堆中字符串的指针
      • String的容量
      • String的长度
    • 可以根据需要调整容量，通过push_str()追加字符串
    • 保证内部只保存标准的UTF-8文本
  2. &str
    • 定义：针对字符串中的特定部分的引用
    • 内存结构：栈上为切片后字符串在堆的起始地址+长度，堆上为被引用的字符串
    • 应用场景：常用于作为只读形参
    • 原则：被部分引用的变量不能通过引用进行原值的修改
    • 切片和双引号的字符串都是&str类型
    let s = String::from("broadcast");
let part1 = &s[0..5];// 0，1，2，3，4
// 参数只读的打印函数
fn greet(name: &str) {// 类似与const &形参
	println!("Hello, {}!", name);
}
// 切片引用不能修改原值
let mut s = String::from("runoob");
let slice = &s[0..3];
s.push_str("yes!"); // 错误
  3. String和&str的转换
    • String 和 str 都支持切片，切片的结果是 &str 类型的数据。
    
let s1 = String::from("hello");
let s2 = &s1[..];// String 转换成 &str
let s3 = s2.tostring();
  4. 切片（Slice）是对数据值的部分引用。切片变量实际为片开始指针 + 大小
    在这里插入图片描述
  5. 范围运算符..，其中x…y 表示 [x, y) 的数学含义
    ..y 	// 等价于 0..y
x.. 	// 等价于位置 x 到数据结束
.. 		// 等价于位置 0 到结束
x..y	// x到y前闭后开
  6. 其他线性数据结构也支持切片操作，例如数组
    let arr = [1, 3, 5, 7, 9];
let part = &arr[0..3];
for i in part.iter() {
    println!("{}", i);
}
```### <font face="黑体" color=purple>strings.1</font>

strings1

简单的&str转换成String对象

fn current_favorite_color() -> String {
    "blue".to_string()
}

strings2

参数类型的更改

fn is_a_color_word(attempt: String) -> bool {
    attempt == "green" || attempt == "blue" || attempt == "red"
}

strings3

注释已经标出


fn trim_me(input: &str) -> String {
    // TODO: Remove whitespace from both ends of a string!
    input.trim().to_string() // trim()除了单词间的空格全部消除
}

fn compose_me(input: &str) -> String {
    // TODO: Add " world!" to the string! There's multiple ways to do this!
    format!("{} world!", input) // 审题
}

fn replace_me(input: &str) -> String {
    // TODO: Replace "cars" in the string with "balloons"!
    input.replace("cars", "balloons") // 替换单词
}

strings4

根据第一个小标题下的切片知识可以做出来

fn main() {
    string_slice("blue");
    string("red".to_string());
    string(String::from("hi"));
    string_slice("rust is fun!".to_owned());
    string_slice("nice weather".into());
    string_slice(format!("Interpolation {}", "Station"));
    string_slice(&String::from("abc")[0..1]);
    string_slice("  hello there ".trim());
    string("Happy Monday!".to_string().replace("Mon", "Tues"));
    string_slice("mY sHiFt KeY iS sTiCkY".to_lowercase());
}

Modules

Modules1

在外面使用，因此需要定义为pub

pub fn make_sausage() {
        get_secret_recipe();
        println!("sausage!");
    }

Modules2

给模块起别名，注意末尾的分号，并且外界需要使用就加pub

pub use self::fruits::PEAR as fruit;
pub use self::veggies::CUCUMBER as veggie;

Modules3

使用 use 关键字来引入标准库

use std::time::{SystemTime, UNIX_EPOCH};

Hashmaps

Hashmaps1

哈希表的定义

let mut basket = HashMap::new();

哈希表的插入

basket.insert(String::from("apple"), 1);
basket.insert(String::from("mango"), 2);

Hashmaps2

通过 entry 获取得到针对某个字符的记录，or_insert在哈希表中检查条目中是否已经存在参数值，没有则插入

basket.entry(fruit).or_insert(1);

Hashmaps3

与上题相同，但需要逻辑判断

let score = scores.entry(team_1_name.clone()).or_insert(Team {
            name: team_1_name,
            goals_scored: 0,
            goals_conceded: 0,
        });
(*score).goals_scored += team_1_score;
(*score).goals_conceded += team_2_score;
let score = scores.entry(team_2_name.clone()).or_insert(Team {
    name: team_2_name,
    goals_scored: 0,
    goals_conceded: 0,
});
(*score).goals_scored += team_2_score;
(*score).goals_conceded += team_1_score;

quiz2

mod my_module {
    use super::Command;

    // TODO: Complete the function signature!
    pub fn transformer(input: Vec<(String, Command)>) -> Vec<String> {
        // TODO: Complete the output declaration!
        let mut output: Vec<String> = vec![];
        for (string, command) in input.iter() {
            // TODO: Complete the function body. You can do it!
            match command {
                Command::Uppercase => {
                    output.push(string.to_uppercase());
                }
                Command::Trim => {
                    output.push(string.trim().to_string());
                }
                Command::Append(usize) => {
                    let mut ans = String::new();
                    for i in 0..*usize {
                        ans += &string.clone();
                    }
                    output.push(format!("{}bar", ans));
                }
            }
        }
        output
    }
}

网上答案可能不行，因为从github上clone下来的项目中的路径配置与本地不同，可能导致相对路径失效，需要使用绝对路径

  // TODO: What do we have to import to have `transformer` in scope?
    use crate::my_module::transformer;

Options

基础知识

  1. 目的：避免出现程序员忘记检查null和none的问题
  2. 用法：
    • 返回值要么是Some(Vaule)，要么是None
  3. Option和Result是枚举(Enum)类型, 枚举的特点是:
    • 同一时间只能存在一个枚举值, 对应非黑即白的独一性
    • 枚举可以把不相干的任意类型组合进行强制打包
    • 在使用match/ if let 等判断语法时候, 必须穷尽一切可能性(或者隐性穷尽, 比如你只需要处理Some的情况) , 对应必须判断这个值是Some 还是None

Options1

按要求返回值，并且在判断时需要进行Some的包含

if time_of_day > 24 {
        None
    } else if time_of_day >= 22 {
        Some(0)
    } else {
        Some(5)
    }
    
#[test]
fn raw_value() {
    // TODO: Fix this test. How do you get at the value contained in the Option?
    let icecreams = maybe_icecream(12);
    assert_eq!(icecreams, Some(5));
}

Options2

这里需要两层 Some 的原因是因为 Vec 的 pop 函数会套一层 Option.

if let Some(word) = optional_target {
	assert_eq!(word, target);
}
while let Some(Some(integer)) = optional_integers.pop() {
    assert_eq!(integer, range);
    range -= 1;
}

Options3

这里是需要让 match 语句不拥有所有权，而是采用借用的方式，采用 ref 关键字。

    match y {
        Some(p) => println!("Co-ordinates are {},{} ", p.x, p.y),
        _ => println!("no match"),
    }

error_handling

基础知识

  1. 异常判断是一个枚举类
enum Result<type(T), type(E)> {
    Ok(T),
    Err(E),
}

// 使用
if name.is_empty() {
   // Empty names aren't allowed.
    Err("`name` was empty; it must be nonempty.".to_string())
} else {
    Ok(format!("Hi! My name is {}", name))
}
  1. ?操作符
    • 只能使用在以Option或者Result作为返回值的函数体中。
let result :Result<T,E1> = ···;
// ？操作符的使用
let ok = result?;
ok;
// 上面语句的去糖展开式
let ok = match result{
	OK(ok) => ok,// 成功则内部值T和作为表达式的返回结果
	Err(err)=>return Err(From::from(err))// 失败则将操作符前的E1转换类型为Result<T, E2>中的E2并返回
};
  1. DST(Dynamically sized types) 是rust里一项非常有用的特性，结合trait object动态派发，在性能开销很小的情况下实现了更灵活的编码
  2. Rust中的调用分配类型
    • 静态派发：在编译期完成
    • 动态派发：将函数的选定和调用延迟到运行时
  3. 组合器
    • 通过各种方式组合T类型的值以建立更复杂的T类型的值
    • 使用组合器自动化地构造很多所需的程序，而不是手工编写每个细节。
  4. 组合器的使用
    • or()和and()组合两个返回值为Option/Result的表达式
      • or()：如果其中一个得到了Some或Ok，该值将立即返回。
      • and()：如果两个都获得Some或Ok，则返回第二个表达式的值。如果其中一个为None或Err，则该值立即返回。
    fn main() {
	let s1 = Some("some1");
	let s2 = Some("some2");
	let n: Option<&str> = None;
​
	let o1: Result<&str, &str> = Ok("ok1");
	let o2: Result<&str, &str> = Ok("ok2");
	let e1: Result<&str, &str> = Err("error1");
	let e2: Result<&str, &str> = Err("error2");
	​
	assert_eq!(s1.or(s2), s1); // Some1 or Some2 = Some1
	assert_eq!(s1.or(n), s1);  // Some or None = Some
	assert_eq!(n.or(s1), s1);  // None or Some = Some
	assert_eq!(n.or(n), n);    // None1 or None2 = None2
	
	assert_eq!(s1.and(s2), s2); // Some1 and Some2 = Some2
	assert_eq!(s1.and(n), n);   // Some and None = None
	assert_eq!(n.and(s1), n);   // None and Some = None
	assert_eq!(n.and(n), n);    // None1 and None2 = None1
    • map() and map_err()：Rust也提供了map()作为迭代器的适配器，以便在迭代器的每个元素上应用闭包，以将其转换为另一个迭代器。
      • map()：通过应用闭包转换类型T。 Some或Ok块的数据类型可以根据闭包的返回类型进行更改。将Option转换为Option，Result<T, E>转换为Result <U, E>
      • Result类型的map_err()：可以根据闭包的返回类型来更改Err块的数据类型。将Result <T, E>转换为Result <T, F>。
    // 类型映射
let s1 = Some("abcde");
let s2 = Some(5);
let fn_character_count = |s: &str| s.chars().count();
let fn_character_count = |s: &str| s.chars().count();
// map_err()，只有Err值被改变
let o1: Result<&str, &str> = Ok("abcde");
let o2: Result<&str, isize> = Ok("abcde");
let fn_character_count = |s: &str| -> isize { s.parse().unwrap() }; // convert str to isize
​assert_eq!(o1.map_err(fn_character_count), o2); // Ok1 map = Ok2

error1

pub fn generate_nametag_text(name: String) -> Result<String, String> {
    if name.is_empty() {
        // Empty names aren't allowed.
        Err("`name` was empty; it must be nonempty.".to_string())
    } else {
        Ok(format!("Hi! My name is {}", name))
    }
}

error2

详情见本节基础知识2

let qty = item_quantity.parse::<i32>()?;

error3

？操作符只能用于返回类型为Result<T, E1> 的函数

fn main() -> Result<(), ParseIntError> {
    let mut tokens = 100;
    let pretend_user_input = "8";
    let cost = total_cost(pretend_user_input)?;
    if cost > tokens {
        println!("You can't afford that many!");
    } else {
        tokens -= cost;
        println!("You now have {} tokens.", tokens);
    }
    Ok(())
}

error4

有对要有错，除了使用？操作符，进行隐式的错误类型转换返回

fn new(value: i64) -> Result<PositiveNonzeroInteger, CreationError> {
    // Hmm...? Why is this only returning an Ok value?
    if value < 0 {
        return Err(CreationError::Negative);
    } else if value == 0 {
        return Err(CreationError::Zero);
    }
    Ok(PositiveNonzeroInteger(value as u64))
}

error5

box作为智能指针可以用于解决编译时大小未知的问题

fn main() -> Result<(), Box<dyn error::Error>> {
    let pretend_user_input = "42";
    let x: i64 = pretend_user_input.parse()?;
    println!("output={:?}", PositiveNonzeroInteger::new(x)?);
    Ok(())
}

error6

这里是需要让 match 语句不拥有所有权，而是采用借用的方式，采用 ref 关键字。

fn from_parseint(err: ParseIntError) -> ParsePosNonzeroError {
    ParsePosNonzeroError::ParseInt(err)
}
// 
let x: i64 = s.parse().map_err(ParsePosNonzeroError::from_parseint)?;
PositiveNonzeroInteger::new(x).map_err(ParsePosNonzeroError::from_creation)

generics

基础知识

generics1

占用符：使编译器自己进行推断类型，类似auto?

let mut shopping_list: Vec<_> = Vec::new();

generics2

模板类的使用


struct Wrapper<T> {
    value: T,
}

impl<T> Wrapper<T>{
    pub fn new(value: T) -> Self {
        Wrapper { value }
    }
}

traits

基础知识

  1. Trait是对一组抽象接口的描述
    • 所有的Trait都定义了一个隐含类型Self，其指向实现该Trait的类型
    • 组成
      • functions（方法）
      • types（类型）
      • constants（常量）
    • Self和self
      • Self：实现Trait的类型的别名
      • self：方法参数 fn f(self) {}，等价于fn f(self: Self) {}
// 接口
 trait Hello {
     fn say_hi(&self) {
         println!("hi");
     }
 }
 ​
 struct Student {}
 impl Hello for Student {}// 给类添加接口
 struct Teacher {}
impl Hello for Teacher {// 接口的重写Override
     fn say_hi(&self) {
         println!("hi, I'm teacher Lee.");
     }
 }
 ​
 fn main() {
     let s = Student {};
     s.say_hi();
     let t = Teacher {};
     t.say_hi();
 }

traits1

注释提示了，第一个函数不应该有所有权，第二个函数应该获得所有权。
所以第一个函数使用借用，第二个函数使用移动语义进行直接传递

impl AppendBar for String {
    // TODO: Implement `AppendBar` for type `String`.
    fn append_bar(self) -> Self {
        format!("{}{}", self, "Bar")
    }
}

traits2

注释提示了，第一个函数不应该有所有权，第二个函数应该获得所有权。
所以第一个函数使用借用，第二个函数使用移动语义进行直接传递


impl AppendBar for Vec<String>
{
    fn append_bar(mut self) -> Self
    {
            self.push("Bar".to_string());
            self
    }
}

traits3

pub trait Licensed {
    fn licensing_info(&self) -> String {
        String::from("Some information")
    }
}

traits4

类对象类型

fn compare_license_types(software: impl Licensed, software_two: impl Licensed) -> bool {
    software.licensing_info() == software_two.licensing_info()
}

test

test1

简单的assert判断

#[cfg(test)]
mod tests {
    #[test]
    fn you_can_assert() {
        assert!(true);
    }
}

test2

注释提示了，第一个函数不应该有所有权，第二个函数应该获得所有权。
所以第一个函数使用借用，第二个函数使用移动语义进行直接传递

#[cfg(test)]
mod tests {
    #[test]
    fn you_can_assert_eq() {
        assert_eq!("a", "a");
    }
}

test3

#[test]
fn is_true_when_even() {
    assert!(is_even(90));
}

#[test]
fn is_false_when_odd() {
    assert!(is_even(92));
}

quiz3

类对象类型

pub struct ReportCard<T> {// 泛型
    pub grade: T, 
    pub student_name: String,
    pub student_age: u8,
}

impl<T: std::fmt::Display> ReportCard<T> {// std::fmt::Display用于异常显示的自定义
    pub fn print(&self) -> String {
        format!(
            "{} ({}) - achieved a grade of {}",
            &self.student_name, &self.student_age, &self.grade
        )
    }
}

#[test]
fn generate_alphabetic_report_card() {
    // TODO: Make sure to change the grade here after you finish the exercise.
    let report_card = ReportCard {
        grade: "A+", // 根据assert进行修改
        student_name: "Gary Plotter".to_string(),
        student_age: 11,
    };
    assert_eq!(
        report_card.print(),
        "Gary Plotter (11) - achieved a grade of A+"
    );
}

lifetimes

基础知识

  1. 函数生命周期
    • 原因：编译器有时无法静态推断函数中形参和返回值的生命周期，需要显式声明参数的生命周期。
    • 目标：防止悬空指针
    • 规则：同名生命周期参数绑定的对象，
// 隐式生命周期
// 编译器在编译时无法推导出返回值，只有运行时才能推导出来
fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

// 显式生命周期
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}
//当编译器看到x: &'a str的时候，'a会被编译器推断为x的生命周期
//当编译器看到y: &'a str的时候，编译器会将'a推断为y的生命周期
//但是此时有冲突，于是编译器会将'a推断为x和y的生命周期中最小的那个。
  1. struct生命周期
    • 当一个生命周期参数修饰多个字段的时候，编译器会将这个生命周期参数推断出这几个字段生命周期最小的那个。
    struct Foo<'a, 'b> {
    x: &'a i32,
    y: &'b i32,
}

fn main() {

    let x = 6;
    let m;                     
// x和y生命周期相同，打印时已经失效
    {                          
        let y = 6;            
        let f = Foo { x: &x, y: &y };  
        m = f.x;             
    }                          

    println!("{}", m);        
}
  2. 省略生命周期声明
    • 函数的每个参数将会赋予各自的生命周期。例如fn foo(x: &i32)将相当于为fn foo<'a>(x: &'a i32)，fn foo(x: &i32, y: &i32)相当于fn foo<'a, 'b>(x: &'a i32, y: &'b i32)，以此类推。
    • 如果输入参数只有一个生命周期参数，那个这个生命周期参数将会被赋予所有输入值。例如fn foo(x: &i32) -> &i32相当于fn foo<'a>(x: &'a i32) -> &'a i32。
    • 在struct的impl语句中，如果有多个输入参数，但是输入参数中有&self或者&mut self，那么self的生命周期将会被赋予所有的书参数。这条规则对于编写struct方法是非常有利的。

lifetimes1

当一个生命周期参数修饰多个字段的时候，编译器会将这个生命周期参数推断出这几个字段生命周期最小的那个。

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

lifetimes2

result被绑定后，在括号时被释放

fn main() {
    let string1 = String::from("long string is long");
    let result;
    {
        let string2 = String::from("xyz");
        result = longest(string1.as_str(), string2.as_str());
        println!("The longest string is '{}'", result);
    }
}

lifetimes3

struct Book<'a, 'b> {
    author: &'a str,
    title: &'b str,
}

iterators

基础知识

  1. 迭代器类型
    • iter返回的是值的不可变引用，即&T
    • iter_mut返回的是值的可变引用，即&mut T
    • into_iter返回的是值的所有权T类型的值

iterators1

值的不可变引用


let mut my_iterable_fav_fruits = my_fav_fruits.iter();   // TODO: Step 1

 assert_eq!(my_iterable_fav_fruits.next(), Some(&"banana"));
 assert_eq!(my_iterable_fav_fruits.next(), Some(&"custard apple"));     // TODO: Step 2
 assert_eq!(my_iterable_fav_fruits.next(), Some(&"avocado"));
 assert_eq!(my_iterable_fav_fruits.next(), Some(&"peach"));     // TODO: Step 3
 assert_eq!(my_iterable_fav_fruits.next(), Some(&"raspberry"));
 assert_eq!(my_iterable_fav_fruits.next(), None);     // TODO: Step 4

iterators2

// to_uppercase函数：返回字符串的大写字母
// collect函数：将一个集合的内容移动到另一个集合的主要方式
// as_str() 可以显式提取包含该字符串的字符串片段
// next函数会让迭代器指向下一个对象
pub fn capitalize_first(input: &str) -> String {
    let mut c = input.chars();
    match c.next() {
        None => String::new(),
        Some(first) => first.to_uppercase().collect::<String>() + c.as_str(),的大写字母
    }
}

// 改变vector中第一个字母为大写字母
pub fn capitalize_words_vector(words: &[&str]) -> Vec<String> {
    let mut col = vec![];
    for word in words
    {
        col.push(capitalize_first(word));
    }
    col 
}

//.join(" ") 将多维数组降维成中间为空格的一维数组
pub fn capitalize_words_string(words: &[&str]) -> String {
    let mut buffer = vec![];
    for word in words {
        buffer.push(capitalize_first(word));
        //println!("{:?}", buffer);
    }

    buffer.join("")
}

iterators3

组合器的拆分

// Calculate `a` divided by `b` if `a` is evenly divisible by `b`.
// Otherwise, return a suitable error.
pub fn divide(a: i32, b: i32) -> Result<i32, DivisionError> {
    if b == 0 {
        return Err(DivisionError::DivideByZero);
    } else if a % b == 0 {
        Ok(a / b)
    } else {
        return Err(DivisionError::NotDivisible(NotDivisibleError {
            dividend: a,
            divisor: b,
        }));
    }
}

// Complete the function and return a value of the correct type so the test passes.
// Desired output: Ok([1, 11, 1426, 3])
fn result_with_list() -> Result<Vec<i32>, DivisionError> {
    let numbers = vec![27, 297, 38502, 81];
    //let division_results = numbers.into_iter().map(|n| divide(n, 27));
    let mut buf = Vec::<i32>::new();
    for n in numbers {
        match divide(n, 27) {
            Ok(r) => buf.push(r),
            Err(e) => return Err(e),
        }
    }

    Ok(buf)
}

// Complete the function and return a value of the correct type so the test passes.
// Desired output: [Ok(1), Ok(11), Ok(1426), Ok(3)]
fn list_of_results() -> Vec<Result<i32, DivisionError>> {
    let numbers = vec![27, 297, 38502, 81];
    //let division_results = numbers.into_iter().map(|n| divide(n, 27));
    let mut buf = Vec::new();

    for n in numbers {
        match divide(n, 27) {
            Ok(r) => buf.push(Ok(r)),
            Err(e) => buf.push(Err(e)),
        }
    }
    buf
}

iterators4

pub fn factorial(num: u64) -> u64 {
    (1..=num).product()// 表示1到num中所有的数字的乘积
}

iterators5

// iter()获取map的迭代器
// filter()HashMap中第一个元素value相等的值
// count()用来返回数量
fn count_iterator(map: &HashMap<String, Progress>, value: Progress) -> usize {
    // map is a hashmap with String keys and Progress values.
    // map = { "variables1": Complete, "from_str": None, ... }
    let count = map.iter().filter(|v| *v.1 == value).count();
    count
}

fn count_collection_iterator(collection: &[HashMap<String, Progress>], value: Progress) -> usize {
    // collection is a slice of hashmaps.
    // collection = [{ "variables1": Complete, "from_str": None, ... },
    //     { "variables2": Complete, ... }, ... ]
    let mut my_map1 = collection[0].clone();
    let mut my_map2 = collection[1].clone();
	// 调用extend方法，将my_map1转换为一个迭代器，并将其键值对添加到my_map2中
    my_map2.extend(my_map1.into_iter());
	// 与上一个相同
    let count11 = my_map2
        .iter()
        .filter(|v| *v.1 == Progress::Complete)
        .count();
    count11
}

threads

基本知识

  1. 进程是资源分配的最小单位，而线程是CPU调度的最小单位。即同一个进程下会有多个线程同时存在，这些线程共同使用一套映射表。
  2. 实现了同一个进程下的两个线程(main线程和spawn线程)
    • main线程执行完毕后会将子线程强制终止：通过join方法解决
    use std::thread;
use std::time::Duration;

fn main() {
    let handle = thread::spawn(||{
        //创建一个子线程
        for i in 1..10 {
            println!("number {} in spawn thread!",i);
            thread::sleep(Duration::from_millis(1));
            //规定输出后的睡眠时间
        }
    });
	
	//handle.join().unwrap();
	//如果将join()设置在这里，则会先进行子线程，等待子线程结束后才会进入主线程执行任务
	
    for j in 1..5 {
        //这里是主线程的任务
        println!("number {} in main thread!",j);
        thread::sleep(Duration::from_millis(1));
    }
    println!("main thread end!");
    handle.join().unwrap();
    //通过join()让主线程结束后等待子线程结束
    //如果不设置，则主线程结束后自动中断子线程
}
  3. 变量所有权问题
    • 关键字move：在闭包中，强制获取环境变量的所有权。防止获取的内存引用失效。
    • 闭包使用了move，则将v的所有权转移给了闭包，此时是无法在main作用域中再次使用v的
    use std::thread;
//use std::time::Duration;

fn main() {
    let v = vec![1,2,3];

    let handle = thread::spawn(move ||{
        println!("{:?}",v);
    });

    handle.join().unwrap();

    println!("Hello, world!");
}

threads1

创建了10个线程，每个线程睡眠250毫秒，然后打印自己的编号和耗时
使用JoinHandle的join方法来等待每个线程结束，并获取它们的返回值

for handle in handles {
	let result = handle.join().unwrap();
    results.push(result);
}

threads2

unwrap函数：计算结果，如果有错误，painc并停止程序

use std::sync::{Arc, Mutex};// 需要使用互斥
use std::thread;
use std::time::Duration;

struct JobStatus {
    jobs_completed: u32,
}

fn main() {
    let status = Arc::new(Mutex::new(JobStatus { jobs_completed: 0 }));// 声明互斥对象
    let mut handles = vec![];
    for _ in 0..10 {
        let status_shared = status.clone();// 拷贝对象
        let handle = thread::spawn(move || {
            thread::sleep(Duration::from_millis(250));
            // TODO: You must take an action before you update a shared value
            status_shared.lock().unwrap().jobs_completed += 1;
        });
        handles.push(handle);
    }
    for handle in handles {
        handle.join().unwrap();
        // TODO: Print the value of the JobStatus.jobs_completed. Did you notice anything
        // interesting in the output? Do you have to 'join' on all the handles?
        println!("jobs completed {}", status.lock().unwrap().jobs_completed);
    }
}

threads3

#[test]
fn is_true_when_even() {
    assert!(is_even(90));
}

#[test]
fn is_false_when_odd() {
    assert!(is_even(92));
}

smart_pointers

box1

Box 类型是一个智能指针，它允许 Box 值被当作引用对待
有详细解释https://www.rustwiki.org.cn/zh-CN/book/ch15-01-box.html?highlight=box#%E4%BD%BF%E7%94%A8-boxt-%E6%8C%87%E5%90%91%E5%A0%86%E4%B8%8A%E7%9A%84%E6%95%B0%E6%8D%AE

pub enum List {
    Cons(i32, Box<List>),// Box将值放在堆上，而不是栈上
    Nil,
}


pub fn create_empty_list() -> List {
    List::Nil
}

pub fn create_non_empty_list() -> List {
    List::Cons(0, Box::new(List::Nil))
}

rc1

Box 自定义了 Drop 用来释放 box 所指向的堆空间。
Rc 记录了堆上数据的引用数量以便可以拥有多个所有者

// TODO
let saturn = Planet::Saturn(Rc::clone(&sun));
println!("reference count = {}", Rc::strong_count(&sun)); // 7 references
saturn.details();

// TODO
let uranus = Planet::Uranus(Rc::clone(&sun));
println!("reference count = {}", Rc::strong_count(&sun)); // 8 references
uranus.details();

// TODO
let neptune = Planet::Neptune(Rc::clone(&sun));
println!("reference count = {}", Rc::strong_count(&sun)); // 9 references
neptune.details();

// TODO
drop(earth);
println!("reference count = {}", Rc::strong_count(&sun)); // 3 references

// TODO
drop(venus);
println!("reference count = {}", Rc::strong_count(&sun)); // 2 references

// TODO
drop(mercury);
println!("reference count = {}", Rc::strong_count(&sun)); // 1 reference

arc1

原子引用计数 Arc，但是原子性的使用会带来性能的降低

let shared_numbers = Arc::new(numbers);// TODO
let child_numbers = Arc::clone(&shared_numbers);// TODO

cow1

  1. Clone-On-Write，即在写入时进行克隆操作。Cow 类型可以用来避免不必要的内存分配和复制操作，从而提高程序的性能和效率
  2. 作用
    • 读写分离：在一些业务场景中，需要对某个数据结构进行多次读取和少量修改，但是每次修改都会导致内存分配和复制操作，从而影响程序的性能和效率。Cow 类型可以通过克隆操作来避免这个问题，从而提高程序的性能和效率。
    • 借用检查：在 Rust 中，借用检查是一项重要的安全特性，可以避免程序中出现内存安全问题。但是，在某些情况下，借用检查会导致代码的复杂度和可读性变差。Cow 类型可以通过引用和克隆操作来解决这个问题，从而简化代码的实现和维护。
// TODO
Cow::Borrowed(_) => Ok(()),
_ => panic!("expected borrowed value"),

// TODO
Cow::Owned(_) => Ok(()),
_ => panic!("expected owned value"),

// TODO
Cow::Owned(_) => Ok(()),
_ => panic!("expected borrowed value"),

smart_pointers

box1

Box 类型是一个智能指针，它允许 Box 值被当作引用对待
有详细解释https://www.rustwiki.org.cn/zh-CN/book/ch15-01-box.html?highlight=box#%E4%BD%BF%E7%94%A8-boxt-%E6%8C%87%E5%90%91%E5%A0%86%E4%B8%8A%E7%9A%84%E6%95%B0%E6%8D%AE

pub enum List {
    Cons(i32, Box<List>),// Box将值放在堆上，而不是栈上
    Nil,
}


pub fn create_empty_list() -> List {
    List::Nil
}

pub fn create_non_empty_list() -> List {
    List::Cons(0, Box::new(List::Nil))
}

rc1

Box 自定义了 Drop 用来释放 box 所指向的堆空间。
Rc 记录了堆上数据的引用数量以便可以拥有多个所有者

// TODO
let saturn = Planet::Saturn(Rc::clone(&sun));
println!("reference count = {}", Rc::strong_count(&sun)); // 7 references
saturn.details();

// TODO
let uranus = Planet::Uranus(Rc::clone(&sun));
println!("reference count = {}", Rc::strong_count(&sun)); // 8 references
uranus.details();

// TODO
let neptune = Planet::Neptune(Rc::clone(&sun));
println!("reference count = {}", Rc::strong_count(&sun)); // 9 references
neptune.details();

// TODO
drop(earth);
println!("reference count = {}", Rc::strong_count(&sun)); // 3 references

// TODO
drop(venus);
println!("reference count = {}", Rc::strong_count(&sun)); // 2 references

// TODO
drop(mercury);
println!("reference count = {}", Rc::strong_count(&sun)); // 1 reference

arc1

原子引用计数 Arc，但是原子性的使用会带来性能的降低

let shared_numbers = Arc::new(numbers);// TODO
let child_numbers = Arc::clone(&shared_numbers);// TODO

macros

macros1

宏调用需要加！

my_macro!();

macros2

宏先声明后使用

macros3

宏模块需要声明

#[macro_use]
mod macros {
    macro_rules! my_macro {
        () => {
            println!("Check out my macro!");
        };
    }
}

macros4

删除#[rustfmt::skip]，Rustfmt 会遍历 mod 树，将该属性放在声明要忽略的模块的文件

clippy

clippy1

  1. clippy 工具是一系列 lint 的集合，用于捕捉常见错误和改进 Rust 代码
//let pi = 3.14f32;
let radius = 5.00f32;

let area = f32::consts::PI * f32::powi(radius, 2);

clippy2

if let Some(x) = option {
        res += x;
    }

clippy3


#[allow(unused_variables, unused_assignments)]
fn main() {
    let my_option: Option<()> = None;
    if my_option.is_none() {
        //my_option.unwrap();
    }

    let my_arr = &[-1, -2, -3 - 4, -5, -6];
    println!("My array! Here it is: {:?}", my_arr);

    let mut my_empty_vec = vec![1, 2, 3, 4, 5];
    my_empty_vec.clear();
    println!("This Vec is empty, see? {:?}", my_empty_vec);

    let mut value_a = 45;
    let mut value_b = 66;
    // Let's swap these two!
    std::mem::swap(&mut value_a, &mut value_b);

    println!("value a: {}; value b: {}", value_a, value_b);
}

conversions

using_as

类型转换

total / values.len() as f64

from_into

impl From<&str> for Person {
    fn from(s: &str) -> Person {
        let (name, age) = match s.split_once(',') {
            Some((name, age)) => (name.trim(), age.trim()),
            _ => return Person::default(),
        };

        if let Ok(age) = age.parse::<usize>() {
            if name.len() > 0 {
                return Person {
                    name: String::from(name),
                    age,
                };
            }
        }

        Person::default()
    }
}

from_str



impl FromStr for Person {
    type Err = ParsePersonError;
    fn from_str(s: &str) -> Result<Person, Self::Err> {
        if s.is_empty() {
            return Err(ParsePersonError::Empty);
        }

        let splitted_item = s.split(',').collect::<Vec<&str>>();
        let (name, age) = match &splitted_item[..] {
            [name, age] => (
                name.to_string(),
                age.parse().map_err(ParsePersonError::ParseInt)?,
            ),
            _ => return Err(ParsePersonError::BadLen),
        };

        if name.is_empty() {
            return Err(ParsePersonError::NoName);
        }

        Ok(Person {
            name: name.into(),
            age,
        })
    }
}

try_from_into

// Tuple implementation
impl TryFrom<(i16, i16, i16)> for Color {
    type Error = IntoColorError;
    fn try_from(tuple: (i16, i16, i16)) -> Result<Self, Self::Error> {
        let (red, green, blue) = tuple;

        for color in [red, green, blue] {
            if !(0..=255).contains(&color) {
                return Err(IntoColorError::IntConversion);
            }
        }
        Ok(Self {
            red: tuple.0 as u8,
            green: tuple.1 as u8,
            blue: tuple.2 as u8,
        })
    }
}

// Array implementation
impl TryFrom<[i16; 3]> for Color {
    type Error = IntoColorError;
    fn try_from(arr: [i16; 3]) -> Result<Self, Self::Error> {
        for color in arr {
            if !(0..=255).contains(&color) {
                return Err(IntoColorError::IntConversion);
            }
        }
        Ok(Self {
            red: arr[0] as u8,
            green: arr[1] as u8,
            blue: arr[2] as u8,
        })
    }
}

// Slice implementation
impl TryFrom<&[i16]> for Color {
    type Error = IntoColorError;
    fn try_from(slice: &[i16]) -> Result<Self, Self::Error> {
        if slice.len() != 3 {
            return Err(IntoColorError::BadLen);
        }
        for color in slice {
            if !(0..=255).contains(color) {
                return Err(IntoColorError::IntConversion);
            }
        }
        Ok(Self {
            red: slice[0] as u8,
            green: slice[1] as u8,
            blue: slice[2] as u8,
        })
    }
}

try_from_into

// Tuple implementation
impl TryFrom<(i16, i16, i16)> for Color {
    type Error = IntoColorError;
    fn try_from(tuple: (i16, i16, i16)) -> Result<Self, Self::Error> {
        let (red, green, blue) = tuple;

        for color in [red, green, blue] {
            if !(0..=255).contains(&color) {
                return Err(IntoColorError::IntConversion);
            }
        }
        Ok(Self {
            red: tuple.0 as u8,
            green: tuple.1 as u8,
            blue: tuple.2 as u8,
        })
    }
}

// Array implementation
impl TryFrom<[i16; 3]> for Color {
    type Error = IntoColorError;
    fn try_from(arr: [i16; 3]) -> Result<Self, Self::Error> {
        for color in arr {
            if !(0..=255).contains(&color) {
                return Err(IntoColorError::IntConversion);
            }
        }
        Ok(Self {
            red: arr[0] as u8,
            green: arr[1] as u8,
            blue: arr[2] as u8,
        })
    }
}

// Slice implementation
impl TryFrom<&[i16]> for Color {
    type Error = IntoColorError;
    fn try_from(slice: &[i16]) -> Result<Self, Self::Error> {
        if slice.len() != 3 {
            return Err(IntoColorError::BadLen);
        }
        for color in slice {
            if !(0..=255).contains(color) {
                return Err(IntoColorError::IntConversion);
            }
        }
        Ok(Self {
            red: slice[0] as u8,
            green: slice[1] as u8,
            blue: slice[2] as u8,
        })
    }
}

最后一个

// Add the AsRef trait appropriately as a trait bound
fn byte_counter<T: AsRef<str>>(arg: T) -> usize {
    arg.as_ref().as_bytes().len()
}

// Obtain the number of characters (not bytes) in the given argument
// Add the AsRef trait appropriately as a trait bound
fn char_counter<T: AsRef<str>>(arg: T) -> usize {
    arg.as_ref().chars().count()
}

// Squares a number using AsMut. Add the trait bound as is appropriate and
// implement the function body.
fn num_sq<T: AsMut<u32>>(arg: &mut T) {
    *arg.as_mut() *= *arg.as_mut()
}

少年，我观你骨骼清奇，颖悟绝伦，必成人中龙凤。
不如点赞·收藏·关注一波

🚩点此跳转到首行↩︎

参考博客

  1. Rust语言圣经(Rust Course)
  2. rust 的引用与借用
  3. Rust 学习笔记
  4. rustlilngs 答案
  5. Rust中some的用法
  6. 组合器
  7. Rust：Trait
  8. Rust三种iterator(iter,iter_mut,into_iter)的区别
  9. Rust学习记录 -＞ 线程Thread
  10. RustCow
  11. Rust学习记录 -＞ 线程Thread
逆羽飘扬
关注
  • 23
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
rust 入门笔记： rustlings（推荐一些学习rust语法的一些非常好的小练习）
云微的blog
07-04 2964
rustlings 推荐一个学习rust非常好的repo： Small exercises to get you used to reading and writing Rust code! - 学习rust语法的一些非常好的小练习 This project contains small exercises to get you used to reading and writing Rust code. This includes reading and responding to compiler m
【RUST】基础
屎蛋的铲屎官
06-17 832
33
Python vs. Rust：打破三大障碍
Warmer_Sweeter
01-16 1160
在我周围的每个人都知道我是Python 的忠实粉丝。大约15年前，当我对 Mathworks Matlab 感到厌倦时，我开始使用Python。虽然Matlab的理念看起来不错，但在掌握了Python之后，我再也没有回头。我甚至成为了我所在大学的Python传道者，"传播这个词"。会编码并不等于成为软件开发者。当我了解到强类型、SOLID原则和通用编程架构等主题时，我也瞥见了其他编程语言以及它们如...
用 rustlings 练习 Rust 语言
2301_80044442的博客
07-06 388
原因在于 Rust 的变量默认是不可变的（immutable），这意味着一旦声明并赋予初始值后，你不能再次修改它，除非你明确地将其声明为可变的。在 Rust 中，这段代码看起来是正确的，但是根据注释提示，可能存在一些不明显的问题。关键字用于定义函数的开始，函数名后面跟着参数列表和返回类型（如果有的话），然后是函数体，它包含了函数执行的具体操作。的类型可以被推断出来，但是显式地声明类型是一个好习惯，特别是在示例代码或教学材料中，因为它可以提高代码的可读性。是函数的参数列表，参数之间用逗号分隔。
rustlings_函数
qq_43413205的博客
05-27 207
前言 函数 在这里，你将会学到如何实现一个函数，同时了解rust的编译器是如何按图索骥。 更进一步的信息 函数是如何运转的 练习一 提示 我们的main函数在试图调用另一个函数，但是它找不到另一个函数。它觉得这个函数应该叫做call_me，它期待这个函数没有参数也不返回值。这听起来很像main函数不是吗？ 题解 从这个练习开始，题目一下子变得有些让人摸不到头脑。不得不承认，这一套题只是一套题而已，它的提示并没有打算让你先学一下，然后再做做看，而是把题目摆在你的面前，然后告诉你，请你来试试看。 函
Rustlings-小练习使您习惯于阅读和编写Rust代码-Rust开发
05-27
沙沙作响:crab::red_heart:问候，并欢迎沙沙作响。 该项目包含一些小练习，以帮助您习惯于阅读和编写Rust代码。 这包括沙沙作响:crab::red_heart:问候，并欢迎沙沙作响。 该项目包含一些小练习，以帮助您习惯于阅读和编写Rust代码。 这包括阅读和响应编译器消息！ ...正在寻找基于Web的Rustlings的旧版本？ 在这里尝试，或者，对于第一次使用Rust的学习者，还有其他一些资源：本书-用于学习Rust的最全面的资源，但有时有些理论性。 您将与Rustlings一起使用它！ 考试生锈
rustlings笔记
玉的博客
06-27 1083
前前后后花了正好半个月的时间写完了rustlings，整个过程像是一路闯关打怪，而我是手持hint和rust圣经的勇者~~（滑稽）~~。现在终于来到boss面前：真实的、从零开始的rust项目开发。前面将没有这种保姆式的教学，可能在开放的rust程序设计中遇到许多未知的挑战。就结果而言，接下来应该做两个看起来不那么基础的项目作为简历加分项，但是我的出发点依然是对coding的热爱。不知道什么时候会熄灭，不过为什么要想到（或认为）它会熄灭呢=v=
rustlings:开始阅读和编写Rust代码的小练习，包括阅读和响应编译器消息！
04-03
问候和欢迎rustlings 。 该项目包含一些小练习，以帮助您习惯于阅读和编写Rust代码。 这包括阅读和响应编译器消息！ ...正在寻找基于Web的Rustlings的旧版本？ 试试 另外，对于首次使用Rust的学习者，还有其他一些...
RustyXML-用Rust编写的XML解析器-Rust开发
05-27
RustyXML文档RustyXML是用Rust编写的可识别名称空间的XML解析器。 现在，它提供了一个类似于SAX的基本API，并在ElementBuilder上提供了RustyXML文档RustyXML是用Rust编写的可识别名称空间的XML解析器。 现在，它提供...
Rust初级面试题及答案Rust初级面试题及答案
最新发布
07-27
Rust初级面试题及答案Rust初级面试题及答案
rustlings:小练习让您习惯于阅读和编写Rust代码-开源
05-13
该项目包含一些小练习，以帮助您习惯于阅读和编写Rust代码。 这包括阅读和响应编译器消息！ 另外，对于首次使用Rust的学习者，还有其他一些资源，例如The Book，这是学习Rust的最全面的资源，但有时有些理论性。 您将与Rustlings一起使用它！ 而且，Rust以身作则，通过解决一些小问题来学习Rust！ 这几乎像沙沙作响，但在线上。 您将需要安装Rust。 练习按主题排序，可以在子目录rustlings / exercises /中找到。 对于每个主题，都有一个附加的自述文件，其中包含一些资源，可帮助您开始学习该主题。 我们真的建议您在开始之前先看看它们。 任务很简单。 大多数练习都包含一个使他们无法编译的错误，这取决于您自己解决！ 一些练习也可以作为测试来运行，但是沙沙处理它们都是一样的。
rustlings-idiomatic-solutions:精选的沙沙作弊解决方案集合
05-24
沙沙作风的解决方案 精选的解决方案集合 与沙沙作响练习类似的结构，不同之处在于每个练习都有以下形式的目录： ./exercises/example/solve1.rs-> ./exercises/example/solve1.rs_/solve1.rs 尾部的“ _”防止名称冲突，并使我们可以为每个练习使用多个示例，以演示好示例和坏示例。
Python-中文翻译rustlangrustlings帮你扶住Rust的那双手
08-10
中文翻译:<rust-lang/rustlings> 帮你扶住 Rust 的那双手 ❤️ ✅
rustlings:让你习惯阅读和编写 Rust 代码的小练习-开源
07-21
这个项目包含一些小练习，让你习惯阅读和编写 Rust 代码。 这包括阅读和响应编译器消息！ 或者，对于第一次 Rust 学习者，还有其他一些资源，比如 The Book，这是学习 Rust 的最全面的资源，但有时有点理论性。 您将与 Rustlings 一起使用它！ 并且，Rust By Example，通过解决小练习来学习 Rust！ 这几乎就像沙沙声，但在网上。 您需要安装 Rust。 练习按主题排序，可以在子目录 rustlings/exercises/ 中找到. 对于每个主题，都有一个额外的 README 文件，其中包含一些资源，可帮助您开始学习该主题。 我们真的建议您在开始之前先看看它们。 任务很简单。 大多数练习都包含一个错误，使它们无法编译，由您来修复它！ 一些练习也作为测试运行，但 rustlings 处理它们都是一样的。
rust-bencode:Rust 语言中的 Bencode 解析器实现
06-04
**锈本码 (Rust-Bencode)：Rust 语言中的 Bencode 解析器实现** 在数字时代，数据编码格式是传输和存储信息的关键部分。Bencode 是 BitTorrent 协议中广泛使用的一种简单且高效的编码方式，用于表示字典、列表、...
利用Rustlings对Rust语言进行学习
Coder_Pig
02-22 4941
Rustlings是什么？ ​ 我们打开Rust官网，可以看到学习下面介绍了三种学习方式，我们可以以《Rust程序设计语言》这本电子书为主来进行快速入门，同时在学习了几个章节后，通过Rustlings进行阅读和编写Rust代码的语法基础。它里面有一些小练习可以让我们更好的了解和学习Rust。 Rustlings如何使用 如何使用我们可以参考官方给出的说明文档Rustlings 个人推荐的两种使用方式 在线使用 在Gitpod中打开 ​ 在Repl.it上运行 将仓库克隆到本地，在
探索Rust编程的奇妙之旅 —— 使用rustlings入坑指南
gitblog_00019的博客
06-06 431
探索Rust编程的奇妙之旅 —— 使用rustlings入坑指南 rustlings-cnRustlings 非官方中文翻译(Rustlings unofficial chinese verion)。???? 让你熟悉阅读和编写 Rust 代码的小练习。源仓库：https://github.com/rust-lang/rustlings项目地址:https://gitcode.com/gh_mirro...
通过rustlings源码了解rust如何从命令行参数里面获取值的方式
qq_43413205的博客
05-27 724
我不知道这篇文章的难度会如何，因为我其实和在看这篇文章的你一样，从零开始学习和了解rustlings的实现方式，通过这个方式，了解rust对main函数的传参。 第一个问题，rustlings使用了什么工具？ 我首先是打开了 src 文件，找到main函数，main函数里面我们看到它在整个函数的开始创建了一个新的对象或者是变量 从这里我们可以看到这个函数的名字是args，类型是Args，很显然这个类型不是我们已知的任何类型，那就ctrl进去先看看这个是什么 struct Args { /// sh
rust 解析xml
03-09
Rust是一种系统级编程语言，它提供了高性能和内存安全的特性。要解析XML文件，可以使用Rust中的一些库来实现。 一个常用的库是`xml-rs`，它提供了对XML的解析和生成功能。你可以在Cargo.toml文件中添加以下依赖项来使用它： ```toml [dependencies] xml-rs = "0.8.0" ``` 然后，在你的Rust代码中，你可以使用`xml-rs`库来解析XML文件。下面是一个简单的示例： ```rust use std::fs::File; use std::io::BufReader; use xml::reader::{EventReader, XmlEvent}; fn main() { let file = File::open("path/to/xml/file.xml").expect("Failed to open XML file"); let reader = BufReader::new(file); let parser = EventReader::new(reader); for event in parser { match event { Ok(XmlEvent::StartElement { name, .. }) => { println!("Start element: {}", name); } Ok(XmlEvent::EndElement { name }) => { println!("End element: {}", name); } Ok(XmlEvent::Characters(text)) => { println!("Text: {}", text); } Err(e) => { println!("Error: {}", e); break; } _ => {} } } } ``` 上述代码使用`xml-rs`库来解析XML文件，并打印出开始元素、结束元素和文本内容。你可以根据自己的需求进行进一步处理。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

逆羽飘扬

如果有用，请支持一下。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值