其他类型

元祖

'()'括号括起来的是元组，元组可以包含不同类型的值。元祖是不可变的，大小，元素的类型都是固定的。

    let tup: (i32, f64, u8) = (500, 6.4, 1);
    let (x, y, z) = tup;
    println!("The value of y is: {y}");

    let x: (((u8, u16), bool), u32) = (((3,4), true), 42);
    println!("x: {:?}", (x.0).0); // Accessing nested tuple values

数组

用于在内存中连续存储固定数量的相同类型的元素。 固定数量的相同类型元素

    let a: [i32; 5] = [1, 2, 3, 4, 5]; // 创建一个包含5个元素的数组，每个元素的类型都是i32
    let b = [3; 5]; // 创建一个包含5个元素的数组，每个元素的值都是3
    println!("a: {:?}, b: {:?}", a, b);

    let mut arr = [1,2,3,4];
    tmp = arr[2];   // 用[]访问元素
    arr[0] = 33;  // 声明为mut后可修改

切片

切片是从其数据源（例如数组或 Vector）借用数据，而不是拥有数据本身

Sting

枚举

#[derive(Debug, PartialEq)] // 可以以使用 {:?} 打印枚举值，并且可以比较枚举值
enum Command {
    Play,
    Stop,
    Skip(u32),
    Back(u32),
    Resize {
        width: u32,
        height: u32,
    },
}

// Debug
println!("command: {:?}", cmd);

    // PartialEq
let cmd0 = Command::Play;
let cmd1 = Command::Stop;
println!("{:?} == {:?}  ? {}", cmd0, cmd1, cmd0 == cmd1);

// Option<T> = Some(T) | None        两个常用的枚举类型
let x: Option<i32> = Some(-1);
let x: Option<i32> = None;
println!("{:?}", x);

// Result<T, E> = Ok(T) | Error(E)
let res: Result<i32, &str> = Ok(100);
let res: Result<i32, &str> = Err("error 💀");
println!("{:?}", res);

结构体

向量

数组：大小固定，在编译时就已确定。一旦数组声明了长度，其长度就不能更改。

向量：大小是动态的。它们的大小会在运行时随着元素的添加或删除而增长或缩小。这种灵活性使得向量非常适合用于预先不知道元素数量或预期元素数量在程序执行期间会发生变化的情况

    let mut vv: Vec<u32> = Vec::new();
    vv.push(1);
    vv.push(2);

    let vvv = vec![1,2,3]; // 使用宏创建一个包含初始值的向量 

    let v : Vec < i8 > = vec! [ 1 , 2 , 3 ]； // 也可以指定元素类型
    println!("vv: {:?}, vvv: {:?}, v: {:?}", vv, vvv
    
    let v = vec![1u8; 5]; // 创建一个包含5个元素的向量，每个元素的值都是1u8
    println!("v: {:?}", v);

    let index_2 = vvv[2]; // 使用索引访问元素

    let index_2 = vvv.get(2); // 使用get方法访问元素，返回Option<&T>
    println!("index_2: {:?}", index_2);

    // 修改元素
    v[0] = 10; // 修改元素

    v.pop(); // 删除最后一个元素 返回弹出的元素


    let v = vec![1, 2, 3, 4, 5];
    let s = &v[1..3];  // &v 表示对向量v的引用， [1..3]表示切片的范围，包含索引1和2，但不包含索引3
    println!("slice: {:?}", s);

get() 如果index有效（在向量的范围内），get()则返回Some(&value)，其中&value是指向该索引处的元素的引用。

如果index超出范围，get()则返回None。

hashmap

HashMap是Rust标准库提供的一种数据结构，用于存储键值对。

use std::collections::HashMap;  // 引入HashMap模块

let mut scores: HashMap<String, u32> = HashMap::new();
scores.insert("yellow".to_stirng(),150);         // 用insert方法插入键值对

println!("scores: {:#?}", scores);

// Get
let score: Option<&u32> = scores.get("red");
println!("red: {:?}", score);

let score = scores.get("green");
println!("green: {:?}", score);



// Upsert
let score: &mut u32 = scores.entry("blue".to_string()).or_insert(0);
*score += 200;

entry 方法返回一个Entry枚举，表示指定键的当前状态 entry(...).or_insert(...) 语句的作用是：如果指定键已经存在于HashMap中，则返回该键对应的值的可变引用；如果指定键不存在于HashMap中，则将该键与提供的默认值（在本例中为0）插入到HashMap中，并返回新插入值的可变引用。 存在就返回，不存在，先插入再返回 *score += 200; 结构体解引用操作符 * 用于访问score引用所指向的值，并将其增加200。