Rust 切片

提示

切片的定义和用途：Rust 切片是一种引用数据类型，用于访问存储在数组、向量和字符串等集合中的部分数据，而不是整个集合。
切片的创建和索引：通过指定开始和结束索引（如 &numbers[1..3]）来创建切片，可以访问原始集合的一部分。起始索引包含在内，而结束索引不包含。
切片的可变性和省略索引：切片可以是不可变的（使用 &）或可变的（使用 &mut），允许修改其指向的数据。在切片表达式中，起始和结束索引可以省略，以引用整个集合或集合的一部分。

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

假设我们有一个数组，

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

现在，如果我们想提取这个数组的第二和第三个元素。我们可以这样切割数组，

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

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

&numbers - 指定了对变量 numbers 的引用（而不是实际的值）
[1..3] - 是一种表示从起始索引 1（包括）到结束索引 3（不包括）的切割数组的符号

示例：Rust 切片

fn main() {
    // 一个数字数组
    let numbers = [1, 2, 3, 4, 5];

    // 创建第二和第三元素的切片
    let slice = &numbers[1..3];

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

输出

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

注意： 切片不是实际的数据，如整数或浮点数，而是对数据块的引用/指针。这就是为什么我们在变量名之前使用了 & 符号。

省略 Rust 切片的索引

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

&variable[start_index..end_index];

例如，

1. 省略切片的起始索引

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

    // 省略起始索引
    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. 省略切片的结束索引

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

    // 省略结束索引
    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. 省略切片的起始和结束索引

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

    // 省略起始和结束索引
    // 引用整个数组
    let slice = &numbers[..];

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

输出

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

在这里，&numbers[..] 没有指定起始和结束索引。这意味 array = [1, 2, 3, 4, 5] slice = [1, 2, 3, 4, 5]

在这里，`&numbers[..]` 中的 `..` 没有开始和结束的索引。这意味着切片从索引 `0` 开始，一直到索引 `5`（不包括）。

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

## Rust 中的可变切片

我们可以通过使用 `&mut` 关键字来创建一个可变切片。

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

一旦将切片标记为可变，我们可以更改切片内的值。让我们看一个例子，

fn main() {
    // 可变数组
    let mut colors = ["red", "green", "yellow", "white"];

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

    // 可变切片
    let sliced_colors = &mut colors[1..3];

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

    // 更改原始切片中第一个索引的值
    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] 创建了一个可变切片 sliced_colors。

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

sliced_colors[1] = "purple"

我们将原始切片 sliced_colors 中第 1 个索引的值从 "yellow" 更改为 "purple"。

常见问题

如何在 Rust 中对字符串进行切片？

就像数组一样，我们也可以在 Rust 中对字符串进行切片。例如，

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

    // 切割字符串
    let slice = &string[0..5];

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

输出

string = Hello World!
slice = Hello

要了解更多关于 Rust 中字符串的信息，请访问 Rust 字符串。

如何在 Rust 中对向量进行切片？

从向量创建切片与我们切割数组的方式非常相似。例如，

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

    // 切割向量
    let slice = &vector[1..4];

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

输出

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

要了解更多关于 Rust 中向量的信息，请访问 Rust 向量。

Rust 切片

示例：Rust 切片​

省略 Rust 切片的索引​

常见问题​

示例：Rust 切片

省略 Rust 切片的索引

常见问题