我必须立刻押注 Rust 之六🎲：数组、切片、循环

数组与切片

数组 是一种固定大小、同一类型元素的集合，声明后大小不可改变。

数组适用于元素数量已知且固定的场景。

示例：

let numbers = [1, 2, 3, 4, 5];  // 定义一个长度为 5 的数组
let zeros = [0; 5];  // 定义一个长度为 5 的数组，每个元素都是 0

切片 是对数组或字符串的一部分的引用。

可以灵活地引用数组的一部分，但不会拥有数组的所有权。

切片的长度由其运行时引用的范围决定，一旦创建了切片，它的长度就无法通过直接修改来改变。

可以重新创建一个切片，选择不同的范围，以达到“改变长度”的效果。

示例：

let numbers = [1, 2, 3, 4, 5];
let mut slice = &numbers[1..4];  // 切片引用数组的第 1 到第 3 个元素

println!("{:?}", slice);  // 输出 [2, 3, 4]

slice = &numbers[2..];  // 切片引用数组的第 2 到最后一个元素

println!("{:?}", slice);  // 输出 [3, 4, 5]

slice = &numbers[0..=4];

println!("{:?}", slice); // 输出 [1, 2, 3, 4, 5];
    

区间语法

• a..b：从 a 开始到 b，不包含 b（半开区间）。
• a..=b：从 a 开始到 b，包含 b（闭区间）。
• ..b：从开始到 b，不包含 b（上限区间）。
• ..=b：从开始到 b，包含 b（上限闭区间）。
• a..：从 a 开始到无限大（下限区间）。
• ..：没有指定上下限的区间，称为无限区间。

区间不仅适用于数字，还适用于其他支持 PartialOrd 和 Step 的类型，如字符。但目前不做过多深入。

循环

Rust 提供多种循环结构，适用于不同的场景。

for 循环

for 循环是遍历数组和切片的最简洁方式：

let arr = [1, 2, 3, 4, 5];

for i in &arr {
    println!("{}", i);
}

for (i, v) in arr.iter().enumerate(){
    println!("i: {}; v: {}", i, v)
}

while 循环

while 循环使用一个计数器逐个访问数组元素：

let arr = [1, 2, 3, 4, 5];
let mut index = 0;
while index < arr.len() {
    let item = arr[index];
    println!("{}", item);
    index += 1;
}

loop 循环

loop 是 Rust 中的无限循环，通过条件控制可以实现类似 while 的遍历：

let arr = [1, 2, 3, 4, 5];
let mut index = 0;
loop {
    if index >= arr.len() {
        break;
    }

    let item = arr[index];
    println!("loop:{}", item);
    index += 1;
}

应用示例

示例：计算数组的总和

fn main() {
    let numbers = [10, 20, 30, 40, 50];
    let mut sum = 0;
    for num in &numbers {
        sum += num;
    }
    println!("Sum: {}", sum);
}

示例：修改切片的元素 通过可变切片修改数组部分内容：

fn main() {
    let mut numbers = [1, 2, 3, 4, 5];
    let slice = &mut numbers[1..4];  // 可变切片

    for num in slice.iter_mut() {
        *num *= 2;  // 将切片中的每个元素翻倍
    }
    
    println!("Modified array: {:?}", numbers);
}