【Rust学习日志】2024.03.04

[Irissssaa]

数组（array）

• 数组的类型是 [T; Length]，数组的长度是类型签名的一部分，因此数组的长度必须在编译期就已知。

流程控制

•   fn main() {
        let n = 5;
    
        let big_n =
            if n < 10 && n > -10 {
                println!(" 数字太小，先增加 10 倍再说");
    
                10 * n
            } else {
                println!("数字太大，我们得让它减半");
    
                n / 2
            };
            //当用if/else作为表达式用来赋值时，要注意在else结束后添加`;`
    
        println!("{} -> {}", n, big_n);
    } 

•   fn main() {
        let mut counter = 0;
    
        let result = loop {
            counter += 1;
    
            if counter == 10 {
                break counter
                //在rust里，break后面可加`;`,也可不加
            }
        };
    
        assert_eq!(result, 20);
    }

模式匹配

match和if let

• 

• 

•   enum MyEnum {
        Foo,
        Bar
    }
    
    fn main() {
        let mut count = 0;
    
        let v = vec![MyEnum::Foo,MyEnum::Bar,MyEnum::Foo];
        for e in v {
            if let MyEnum::Foo = e { 
                count += 1;
            }//这里不能交换e和MyEnum::Foo的顺序，原因如下：
            //在 Rust 中，if let 语法用于模式匹配和解构值。在这种情况下，if let MyEnum::Foo = e 的意思是尝试将 e 解构为 MyEnum::Foo，如果成功，则执行相应的代码块。而如果写成 if let e =MyEnum::Foo，则表示将 MyEnum::Foo 解构为 e，这在语义上是不正确的，因为 MyEnum::Foo 不是一个可解构的值。
        }
    
        assert_eq!(count, 2);
    }

• 在 Rust 中，== 是用于比较两个值是否相等的运算符，而匹配模式中的 = 则是用于模式匹配和变量绑定的操作符。

  具体来说：

  • == 运算符用于比较两个值是否相等，如果相等则返回 true，否则返回 false。例如：a == b 表示比较 a 和 b 的值是否相等。
  • 匹配模式中的 = 用于模式匹配和变量绑定。在 match 表达式或 if let 表达式中，可以使用 = 将某个值与模式进行匹配，并将匹配成功的部分进行变量绑定。例如：if let Some(i) = o 表示将 o 与 Some(i) 进行匹配，并将成功匹配的 i 绑定到变量上。

•   fn main() {
        let age = Some(30);
        if let Some(age) = age { // 创建一个新的变量，该变量与之前的 `age` 变量同名
           assert_eq!(age, 30);
        } // 新的 `age` 变量在这里超出作用域
        
        match age {
            // `match` 也能实现变量遮蔽,并且不明显
            Some(age) =>  println!("age 是一个新的变量，它的值是 {}",age),
            _ => ()
        }
     }

解构Option

模式适用场景

• 在 Rust 中，模式匹配可以分为可驳匹配模式（irrefutable patterns）和不可驳匹配模式（refutable patterns）两种类型：

  • 可驳匹配模式（irrefutable patterns）：
    可驳匹配模式是指无论如何都能匹配成功的模式，不会导致匹配失败。在使用可驳匹配模式时，编译器总是能够保证模式匹配成功，因此不会出现编译错误。通常用于 if let、while let 和函数参数等地方。示例：

   if let Some(x) = some_option_value {
       println!("{}", x);
   }

  • 不可驳匹配模式（refutable patterns）：

    不可驳匹配模式是指可能会匹配失败的模式，也就是存在某些情况下无法匹配成功。在使用不可驳匹配模式时，编译器无法保证模式一定会匹配成功，因此需要处理可能的匹配失败情况，否则会导致编译错误。通常用于 match 语句中的分支和 let 语句的左侧。示例：

     let x: Option<i32> = None;
     match x {
         Some(value) => {
             println!("Value is {}", value);
         }
         None => {
             println!("No value");
         }
     }

全模式列表

• 在 Rust 中，assert! 宏接受一个表达式作为参数，该表达式的值应该是布尔类型（即 true 或 false）。当表达式的值为 false 时，assert! 宏会触发 panic。因此，你可能会使用类似 assert!(a == 1); 这样的形式来断言某个条件是否成立。
  对于 assert!(a, 1); 这种形式，这实际上是一个语法错误，因为 assert! 宏需要的是一个布尔表达式，而不是单独的两个参数。正确的用法应该是像上面提到的那样使用布尔表达式。
  如果想要断言某个值等于某个特定值，可以这样写：assert_eq!(a, 1);

  这里使用了 assert_eq! 宏，它用于比较两个值是否相等，如果不相等则触发 panic。

  像assert!(matches!(arr,[..]))；这种就是先通过matches！得到一个布尔类型的参数，然后用assert！进行断言。

•   let arr: &[u16] = &[114, 514];
    
    if let [x, ..] = arr {
        assert_eq!(x, &114);
    }
    
    if let &[.., y] = arr {
        assert_eq!(y, 514);
    }
    //关于这里的`&`使用问题，理解如下：首先arr本身就是切片引用，进行模式匹配后，x自然匹配的就是引用本身即&114，而y匹配的就是值本身即514

•   fn main() {
        let x = Some(5);
        let y = 10;
    
        if let Some(_x) = x {
            println!("Matched"); 
        }
    
        println!("Outside: {:?}", x);
    
    }//可以运行
    
    fn main(){
        let s =Some(String::from("Hello!"));
    
        if let Some(_s) = s {
        println!("found a string");
        }
    
        println!("{:?}", s);//s失效了
    }
    

  上面这两串代码的区别在于 s 是 String 类型，而 x 是一个整数 i32 类型。在 Rust 中，对于像 i32 这样的基本类型，其实现了 Copy trait，因此在使用 if let 语句时，原始变量仍然是可用的。这意味着在第一个示例中，虽然 x 变量在 if let 语句中已经被匹配并损毁了，但它仍然可以在后续代码中使用，因为这个类型可以通过复制来恢复。

  对于 String 类型，它没有实现 Copy trait，因此在第二个示例中，当你使用 if let 来解构 String 变量 s 时，如果匹配成功，就会移动 s 的所有权，导致后续无法再使用 s，因为它已经在 if let 语句中被消耗掉了。

  此处并不是覆盖性的问题。

• 在 Rust 中，vector.pop() 方法返回一个 Option<T> 类型的值，其中 T 是向量中元素的类型。当向量为空时，pop() 方法会返回 None，否则返回 Some(element)，其中 element 是被弹出的元素。