Rust 切片

Rust slice 是一种数据类型，用于访问存储在数组、向量和字符串等集合中的数据片段。

假设我们有一个数组，

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

现在，如果我们想提取该数组的**第二**和**第三**个元素。我们可以像这样对数组进行切片：

let slice = &array[1..3];

这里，我们来看看表达式的右侧，

• &numbers - 指定对变量 numbers 的引用（而非实际值）
• [1..3] - 是一个切片表示法，用于从**起始索引** 1（包含）到**结束索引** 3（不包含）对数组进行切片

示例：Rust Slice

fn main() {
    // an array of numbers
    let numbers = [1, 2, 3, 4, 5];
    
    // create a slice of 2nd and 3rd element
    let slice = &numbers[1..3];
    
    println!("array = {:?}", numbers);
    println!("slice = {:?}", slice);
}

输出

array = [1, 2, 3, 4, 5]
slice = [2, 3]

注意： Slice 本身不是数据（如整数或浮点数），而是数据块的引用/指针。这就是为什么我们在变量名前使用了 & 符号。

省略 Rust Slice 的索引

在对数据集合进行切片时，Rust 允许我们在其语法中省略起始索引、结束索引或两者都省略。

&variable[start_index..end_index];

例如，

1. 省略 Slice 的起始索引

fn main() {
    let numbers = [1, 2, 3, 4, 5];

    // omit the start index
    let slice = &numbers[..3];

    println!("array = {:?}", numbers);
    println!("slice = {:?}", slice);
}

输出

array = [1, 2, 3, 4, 5]
slice = [1, 2, 3]

这里，&numbers[..3] 包含 ..3 而没有起始索引。这意味着切片从索引 0 开始，直到索引 3（不包含）。它等同于 &numbers[0..3]。

2. 省略 Slice 的结束索引

fn main() {
    let numbers = [1, 2, 3, 4, 5];

    // omit the end index
    let slice = &numbers[2..];

    println!("array = {:?}", numbers);
    println!("slice = {:?}", slice);
}

输出

array = [1, 2, 3, 4, 5]
slice = [3, 4, 5]

这里，&numbers[2..] 包含 2.. 而没有结束索引。这意味着切片从索引 2 开始，直到索引 5（不包含）。它等同于 &numbers[2..5]。

3. 省略 Slice 的起始和结束索引

fn main() {
    let numbers = [1, 2, 3, 4, 5];
    
    // omit the start index and the end index
    // reference the whole array
    let slice = &numbers[..];

    println!("array = {:?}", numbers);
    println!("slice = {:?}", slice);
}

输出

array = [1, 2, 3, 4, 5]
slice = [1, 2, 3, 4, 5]

这里，&numbers[..] 包含 .. 而没有起始和结束索引。这意味着切片从索引 0 开始，直到索引 5（不包含）。

它等同于 &numbers[0..5]，这将产生相同的切片并引用整个数组。

Rust 中的可变 Slice

我们可以使用 &mut 关键字创建一个可变 Slice。

let numbers = [1, 2, 3, 4, 5];
let slice = &mut numbers[1..4];

一旦 Slice 被标记为可变，我们就可以更改 Slice 中的值。让我们看一个例子，

fn main() {
    // mutable array
    let mut colors = ["red", "green", "yellow", "white"];
    
    println!("array = {:?}", colors);

    // mutable slice
    let sliced_colors = &mut colors[1..3];
    
    println!("original slice = {:?}", sliced_colors);

    // change the value of the original slice at the first index
    sliced_colors[1] = "purple";

    println!("changed slice = {:?}", sliced_colors);
}

输出

array = ["red", "green", "yellow", "white"]
original slice = ["green", "yellow"]
changed slice = ["green", "purple"]

在这里，我们创建了一个可变数组 colors。然后，我们使用 &mut array[1..3] 创建了一个可变 Slice sliced_colors。

现在，我们可以更改可变 Slice 的内容，

sliced_colors[1] = "purple"

我们将原始 Slice sliced_colors 的第一个索引处的值从 "yellow" 更改为 "purple"。

fn main() {
    let string = String::from("Hello World!");

    // slicing a string
    let slice = &string[0..5];

    println!("string = {}", string);
    println!("slice = {}", slice);
}

string = Hello World!
slice = Hello

fn main() {
    let vector = vec!['A', 'E', 'I', 'O', 'U'];

    // slicing a vector
    let slice = &vector[1..4];

    println!("vector = {:?}", vector);
    println!("slice = {:?}", slice);
}

vector = ['A', 'E', 'I', 'O', 'U']
slice = ['E', 'I', 'O']