【Rust学习日志】2024.04.03

[Irissssaa]

集合类型

动态数组（Vector）

•   let mut v = vec![1, 2, 3, 4, 5];
    
    let first = &v[0];
    
    v.push(6);
    
    println!("The first element is: {first}");
    

  上面的代码中，first 这个不可变借用在可变借用 v.push 后被使用了，那么妥妥的，编译器就会报错，原因在于：数组的大小是可变的，当旧数组的大小不够用时，Rust 会重新分配一块更大的内存空间，然后把旧数组拷贝过来。这种情况下，之前的引用显然会指向一块无效的内存。

• Vector常见的一些方法示例：

   let mut v =  vec![1, 2];
   assert!(!v.is_empty());         // 检查 v 是否为空
   
   v.insert(2, 3);                 // 在指定索引插入数据，索引值不能大于 v 的长度， v: [1, 2, 3] 
   assert_eq!(v.remove(1), 2);     // 移除指定位置的元素并返回, v: [1, 3]
   assert_eq!(v.pop(), Some(3));   // 删除并返回 v 尾部的元素，v: [1]
   assert_eq!(v.pop(), Some(1));   // v: []
   assert_eq!(v.pop(), None);      // 记得 pop 方法返回的是 Option 枚举值
   v.clear();                      // 清空 v, v: []
   
   let mut v1 = [11, 22].to_vec(); // append 操作会导致 v1 清空数据，增加可变声明
   v.append(&mut v1);              // 将 v1 中的所有元素附加到 v 中, v1: []
   v.truncate(1);                  // 截断到指定长度，多余的元素被删除, v: [11]
   v.retain(|x| *x > 10);          // 保留满足条件的元素，即删除不满足条件的元素
   
   let mut v = vec![11, 22, 33, 44, 55];
   // 删除指定范围的元素，同时获取被删除元素的迭代器, v: [11, 55], m: [22, 33, 44]
   let mut m: Vec<_> = v.drain(1..=3).collect();    
   
   let v2 = m.split_off(1);        // 指定索引处切分成两个 vec, m: [22], v2: [33, 44]
   

• vec!(..) 和 vec![..] 是同样的宏，宏可以使用 []、()、{}三种形式

• 当创建一个新的 Vec 时，有几种常见的方法，包括 Vec::new()、vec![] 和 Vec::from()。它们之间的区别在于如何初始化向量以及==它们接受的参数类型==。

  1. Vec::new()： 这是一个 Vec 类型的关联函数，用于创建一个空的向量，没有任何元素。你可以在创建后使用 push 方法来逐步添加元素。

     let mut v = Vec::new();
     v.push(1);
     v.push(2);
     v.push(3);

  2. vec![] 宏： 这是一个 Rust 宏，用于创建包含指定元素的向量。你可以在 vec![] 宏中列出向量中的元素。

     let v = vec![1, 2, 3];
     //为了更好的理解有下面这个例子：
     let arr: [u8;3] = [1, 2, 3];
     let v = vec![arr];
     //v=[[1,2,3]]，此时arr就成了v的一个元素

  3. Vec::from()： 这是 Vec 类型的另一个关联函数，它接受一个实现了 IntoIterator trait 的对象，并将其转换为一个 Vec。通常情况下，你可以传递一个数组作为参数给 Vec::from()，从而创建一个包含数组元素的向量。

     let arr: [u8; 3] = [1, 2, 3];
     let v = Vec::from(arr);
     //v=[1,2,3]

  总结一下：

  • 如果想要创建一个空的向量，你可以使用 Vec::new()。
  • 如果知道向量中的元素并且想要在创建时指定它们，你可以使用 vec![] 宏。
  • 如果已经有一个实现了 IntoIterator trait 的对象（比如数组），你可以使用 Vec::from() 将其转换为一个向量。

• 下面是一道例题：

   fn main() {
       let arr: [u8; 3] = [1, 2, 3];
       
       let v = Vec::from(arr);
       is_vec(v);
   
       let v = vec![1, 2, 3];
       is_vec(v);
   
       let v = vec!(1, 2, 3);
       is_vec(v);
       
       // 在下面的代码中, v 是 Vec<[u8; 3]> , 而不是 Vec<u8>
       // 使用 Vec::new 和 `for` 来重写下面这段代码
       let v1 = vec!(arr);
       is_vec(v1);
    
       assert_eq!(v, v1);
   
       println!("Success!")
   }
   
   fn is_vec(v: Vec<u8>) {}

   fn main() {
       let arr: [u8; 3] = [1, 2, 3];
       
       let v = Vec::from(arr);
       is_vec(v.clone());
   
       let v = vec![1, 2, 3];
       is_vec(v.clone());
   
       let v = vec!(1, 2, 3);
       is_vec(v.clone());
   
       let mut v1 = Vec::new();
       for &i in &arr{
           v1.push(i);
       }//这里使用&i是有原因的
       is_vec(v1.clone());
       //若不使用&，此处则会报错
       /*
      |     is_vec(v1.clone());
      |     ------ ^^^^^^^^^^ expected `Vec<u8>`, found `Vec<&u8>`
       */
       assert_eq!(v, v1);
   
       println!("Success!")
   }
   
   fn is_vec(v: Vec<u8>) {}

• unwrap() 是一个 Option 和 Result 类型的方法，它用于获取这些类型的值。它的作用如下：

  1. Option 类型： 在 Rust 中，Option 类型是用来表示一个可能有值也可能没有值的情况。它有两个变体：Some(T) 表示一个包含值的情况，None 表示没有值。当你对一个 Option 类型的值调用 unwrap() 方法时，如果值是 Some(T)，它会返回包含的值 T；如果值是 None，unwrap() 方法会导致程序 panic，也就是非正常退出，并打印一条错误信息。所以在使用 unwrap() 时，需要确保对应的 Option 值不是 None，否则会导致程序崩溃。
  2. Result 类型： 在 Rust 中，Result 类型用于表示可能发生错误的操作的结果。它有两个变体：Ok(T) 表示操作成功并返回了一个值 T，Err(E) 表示操作失败并返回了一个错误 E。unwrap() 方法在 Result 类型上的行为与 Option 类型类似：如果值是 Ok(T)，它会返回包含的值 T；如果值是 Err(E)，unwrap() 方法会导致程序 panic，并打印包含错误信息的错误消息。因此，与 Option 类型一样，使用 unwrap() 方法时需要确保对应的 Result 值不是 Err(E)。

• partial_cmp 是 Rust 中用于比较两个值的方法之一。它返回一个 Option<Ordering>，表示两个值之间的比较结果。

  partial_cmp 方法是在 PartialOrd trait 中定义的，它==允许类型在可能不总是可比较的情况下进行比较==。对于那些无法定义完全排序关系的类型，如浮点数中的 NaN (非数值)，就使用了 PartialOrd trait。

  Option<Ordering> 是一个枚举类型，可能的取值有两种：

  • Some(Ordering)：表示两个值之间有明确的排序关系，可以是 Less、Equal 或 Greater。
  • None：表示两个值之间没有明确的排序关系，通常在比较类型不支持的情况下返回。

  例如，如果你有两个整数 a 和 b，你可以使用 a.partial_cmp(&b) 来比较它们，并根据返回值来确定它们的相对顺序。

  以下是一个示例：

   fn main() {
       let a = 5;
       let b = 10;
       
       match a.partial_cmp(&b) {
           Some(ordering) => {
               if ordering == std::cmp::Ordering::Less {
                   println!("a is less than b");
               } else if ordering == std::cmp::Ordering::Equal {
                   println!("a is equal to b");
               } else {
                   println!("a is greater than b");
               }
           },
           None => {
               println!("Values are not comparable");
           }
       }
   }

KV储存HashMap

• 在 Rust 中，Option 类型是一个枚举类型，其 copied 方法如下：

  copied 方法用于将 Option<&T> 转换为 Option<T>，其中 T 必须实现 Copy trait。这个方法通常用于在需要值的情况下，将 Option<&T> 转换为 Option<T>，并复制底层值。

   fn main() {
       let x: Option<i32> = Some(5);
       let y: Option<i32> = None;
   
       // 将 Option<&T> 转换为 Option<T>
       let copied_x = x.copied();  // 结果为 Some(5)
       let copied_y = y.copied();  // 结果为 None
   
       println!("{:?}, {:?}", copied_x, copied_y);
   }

  unwrap_or 方法如下：

  unwrap_or 方法用于从 Option 中获取值，如果 Option 是 Some，则返回其中的值；如果 Option 是 None，则返回一个默认值。

   fn main() {
       let x: Option<i32> = Some(5);
       let y: Option<i32> = None;
   
       // 获取 Option 中的值，如果是 Some，则返回其中的值，如果是 None，则返回默认值
       let result_x = x.unwrap_or(0);  // 结果为 5
       let result_y = y.unwrap_or(0);  // 结果为 0
   
       println!("{}, {}", result_x, result_y);
   }

  使用 unwrap_or 方法时，如果 Option 是 Some，则返回其中的值；如果是 None，则返回传入的参数作为默认值。这个方法允许您指定一个默认值，以防止出现 None 的情况。

• 更新 HashMap 中的值

   fn main() {
       use std::collections::HashMap;
   
       let mut scores = HashMap::new();
   
       scores.insert("Blue", 10);
   
       // 覆盖已有的值
       let old = scores.insert("Blue", 20);
       assert_eq!(old, Some(10));
       //其中insert方法返回的是被覆盖的旧值的option类型
   
       // 查询新插入的值
       let new = scores.get("Blue");
       assert_eq!(new, Some(&20));
   	//其中get方法返回的是option类型的引用值
       
       // 查询Yellow对应的值，若不存在则插入新值
       let v = scores.entry("Yellow").or_insert(5);
       assert_eq!(*v, 5); // 不存在，插入5
   	//返回的是引用类型
       
       // 查询Yellow对应的值，若不存在则插入新值
       let v = scores.entry("Yellow").or_insert(50);
       assert_eq!(*v, 5); // 已经存在，因此50没有插入
   }