Rust 编程语言

使用字符串存储 UTF-8 编码的文本

我们在第 4 章中讨论过字符串，但现在我们将更深入地研究它们。Rust 新手通常会在字符串上遇到困难，原因有三：Rust 倾向于暴露可能的错误，字符串比许多程序员认为的更复杂，以及 UTF-8。当你从其他编程语言转向 Rust 时，这些因素结合在一起可能会让你觉得困难。

我们在集合的上下文中讨论字符串，因为字符串是作为字节集合实现的，并带有一些方法，以便在将这些字节解释为文本时提供有用的功能。在本节中，我们将讨论 String 上的每个集合类型都具有的操作，例如创建、更新和读取。我们还将讨论 String 与其他集合的不同之处，即如何通过人和计算机解释 String 数据的方式之间的差异来索引 String。

什么是字符串？

我们将首先定义“字符串”一词的含义。Rust 在核心语言中只有一种字符串类型，即字符串切片 str，它通常以其借用形式 &str 出现。在第 4 章中，我们讨论了*字符串切片*，它们是对存储在其他地方的一些 UTF-8 编码字符串数据的引用。例如，字符串字面量存储在程序的二进制文件中，因此是字符串切片。

String 类型由 Rust 的标准库提供，而不是编码到核心语言中，它是一种可增长的、可变的、拥有的、UTF-8 编码的字符串类型。当 Rustaceans 在 Rust 中提到“字符串”时，他们可能指的是 String 或字符串切片 &str 类型，而不仅仅是其中一种类型。虽然本节主要讨论 String，但这两种类型在 Rust 的标准库中都大量使用，并且 String 和字符串切片都是 UTF-8 编码的。

创建新字符串

许多可用于 Vec<T> 的操作也适用于 String，因为 String 实际上是作为带有一些额外保证、限制和功能的字节向量的包装器实现的。一个在 Vec<T> 和 String 中工作方式相同的函数示例是用于创建实例的 new 函数，如清单 8-11 所示。

fn main() {
    let mut s = String::new();
}

清单 8-11：创建一个新的空 String

此行创建了一个名为 s 的新空字符串，我们可以将数据加载到其中。通常，我们会有一些初始数据，我们希望字符串以这些数据开头。为此，我们使用 to_string 方法，该方法可用于实现 Display 特征的任何类型，就像字符串字面量一样。清单 8-12 显示了两个示例。

fn main() {
    let data = "initial contents";

    let s = data.to_string();

    // the method also works on a literal directly:
    let s = "initial contents".to_string();
}

清单 8-12：使用 to_string 方法从字符串字面量创建 String

此代码创建一个包含 initial contents 的字符串。

我们还可以使用函数 String::from 从字符串字面量创建 String。清单 8-13 中的代码等效于清单 8-12 中使用 to_string 的代码。

fn main() {
    let s = String::from("initial contents");
}

清单 8-13：使用 String::from 函数从字符串字面量创建 String

因为字符串用于很多地方，所以我们可以对字符串使用许多不同的泛型 API，这为我们提供了很多选择。其中一些看起来可能是多余的，但它们都有自己的位置！在这种情况下，String::from 和 to_string 做同样的事情，所以你选择哪一个取决于风格和可读性。

请记住，字符串是 UTF-8 编码的，因此我们可以像清单 8-14 中所示那样在其中包含任何正确编码的数据。

fn main() {
    let hello = String::from("السلام عليكم");
    let hello = String::from("Dobrý den");
    let hello = String::from("Hello");
    let hello = String::from("שלום");
    let hello = String::from("नमस्ते");
    let hello = String::from("こんにちは");
    let hello = String::from("안녕하세요");
    let hello = String::from("你好");
    let hello = String::from("Olá");
    let hello = String::from("Здравствуйте");
    let hello = String::from("Hola");
}

清单 8-14：在字符串中存储不同语言的问候语

这些都是有效的 String 值。

更新字符串

String 的大小可以增长，其内容也可以更改，就像 Vec<T> 的内容一样，如果你将更多数据推送到其中。此外，你可以方便地使用 + 运算符或 format! 宏来连接 String 值。

使用 push_str 和 push 追加到字符串

我们可以通过使用 push_str 方法追加字符串切片来增加 String 的大小，如清单 8-15 所示。

fn main() {
    let mut s = String::from("foo");
    s.push_str("bar");
}

清单 8-15：使用 push_str 方法将字符串切片追加到 String

在这两行之后，s 将包含 foobar。push_str 方法采用字符串切片，因为我们不一定想要获取参数的所有权。例如，在清单 8-16 中的代码中，我们希望能够在将 s2 的内容追加到 s1 之后使用 s2。

fn main() {
    let mut s1 = String::from("foo");
    let s2 = "bar";
    s1.push_str(s2);
    println!("s2 is {s2}");
}

清单 8-16：在将字符串切片的内容追加到 String 之后使用它

如果 push_str 方法获取了 s2 的所有权，我们将无法在最后一行打印其值。但是，此代码按预期工作！

`push` 方法接受一个字符作为参数，并将其添加到 `String` 中。代码清单 8-17 使用 `push` 方法将字母 “l” 添加到 `String` 中。

fn main() {
    let mut s = String::from("lo");
    s.push('l');
}

代码清单 8-17：使用 `push` 向 `String` 值添加一个字符

结果，`s` 将包含 `lol`。

使用 `+` 运算符或 `format!` 宏进行拼接

通常，您需要将两个现有的字符串组合在一起。一种方法是使用 `+` 运算符，如代码清单 8-18 所示。

fn main() {
    let s1 = String::from("Hello, ");
    let s2 = String::from("world!");
    let s3 = s1 + &s2; // note s1 has been moved here and can no longer be used
}

代码清单 8-18：使用 `+` 运算符将两个 `String` 值组合成一个新的 `String` 值

字符串 `s3` 将包含 `Hello, world!`。`s1` 在加法运算后不再有效，以及我们使用对 `s2` 的引用的原因，与使用 `+` 运算符时调用的方法的签名有关。`+` 运算符使用 `add` 方法，其签名如下所示

fn add(self, s: &str) -> String {

在标准库中，您将看到使用泛型和关联类型定义的 `add`。在这里，我们替换了具体的类型，这就是当我们使用 `String` 值调用此方法时发生的情况。我们将在第 10 章讨论泛型。此签名为我们提供了理解 `+` 运算符的棘手部分所需的线索。

首先，`s2` 有一个 `&`，这意味着我们将第二个字符串的*引用*添加到第一个字符串中。这是因为 `add` 函数中的 `s` 参数：我们只能将 `&str` 添加到 `String` 中；我们不能将两个 `String` 值加在一起。但是等等——`&s2` 的类型是 `&String`，而不是 `add` 的第二个参数中指定的 `&str`。那么为什么代码清单 8-18 可以编译呢？

我们能够在调用 `add` 时使用 `&s2` 的原因是编译器可以将 `&String` 参数*强制转换*为 `&str`。当我们调用 `add` 方法时，Rust 使用*解引用强制转换*，这里将 `&s2` 转换为 `&s2[..]`。我们将在第 15 章更深入地讨论解引用强制转换。因为 `add` 不获取 `s` 参数的所有权，所以 `s2` 在此操作后仍然是一个有效的 `String`。

其次，我们可以在签名中看到 `add` 获取了 `self` 的所有权，因为 `self`*没有* `&`。这意味着代码清单 8-18 中的 `s1` 将被移动到 `add` 调用中，并且在此之后不再有效。因此，尽管 `let s3 = s1 + &s2;` 看起来像是复制了两个字符串并创建了一个新字符串，但此语句实际上获取了 `s1` 的所有权，追加了 `s2` 内容的副本，然后返回结果的所有权。换句话说，它看起来像是进行了很多复制，但实际上并非如此；该实现比复制更有效率。

如果我们需要连接多个字符串，`+` 运算符的行为会变得很笨拙

fn main() {
    let s1 = String::from("tic");
    let s2 = String::from("tac");
    let s3 = String::from("toe");

    let s = s1 + "-" + &s2 + "-" + &s3;
}

此时，`s` 将是 `tic-tac-toe`。由于所有 `+` 和 `"` 字符，很难看出发生了什么。对于更复杂的字符串组合，我们可以改用 `format!` 宏

fn main() {
    let s1 = String::from("tic");
    let s2 = String::from("tac");
    let s3 = String::from("toe");

    let s = format!("{s1}-{s2}-{s3}");
}

此代码还将 `s` 设置为 `tic-tac-toe`。`format!` 宏的工作方式类似于 `println!`，但它不是将输出打印到屏幕上，而是返回一个包含内容的 `String`。使用 `format!` 的代码版本更易于阅读，并且 `format!` 宏生成的代码使用引用，因此此调用不会获取其任何参数的所有权。

字符串索引

在许多其他编程语言中，通过索引引用字符串中的单个字符是一种有效且常见的操作。但是，如果您尝试使用 Rust 中的索引语法访问 `String` 的部分内容，则会出现错误。请考虑代码清单 8-19 中的无效代码。

fn main() {
    let s1 = String::from("hello");
    let h = s1[0];
}

代码清单 8-19：尝试对 String 使用索引语法

此代码将导致以下错误

$ cargo run
   Compiling collections v0.1.0 (file:///projects/collections)
error[E0277]: the type `String` cannot be indexed by `{integer}`
 --> src/main.rs:3:16
  |
3 |     let h = s1[0];
  |                ^ `String` cannot be indexed by `{integer}`
  |
  = help: the trait `Index<{integer}>` is not implemented for `String`
  = help: the following other types implement trait `Index<Idx>`:
            <String as Index<RangeFull>>
            <String as Index<std::ops::Range<usize>>>
            <String as Index<RangeFrom<usize>>>
            <String as Index<RangeTo<usize>>>
            <String as Index<RangeInclusive<usize>>>
            <String as Index<RangeToInclusive<usize>>>

For more information about this error, try `rustc --explain E0277`.
error: could not compile `collections` (bin "collections") due to 1 previous error

错误和注释说明了问题所在：Rust 字符串不支持索引。但为什么不支持呢？要回答这个问题，我们需要讨论 Rust 如何在内存中存储字符串。

内部表示

`String` 是 `Vec<u8>` 的包装器。让我们看一下代码清单 8-14 中一些经过正确编码的 UTF-8 示例字符串。首先是这个

fn main() {
    let hello = String::from("السلام عليكم");
    let hello = String::from("Dobrý den");
    let hello = String::from("Hello");
    let hello = String::from("שלום");
    let hello = String::from("नमस्ते");
    let hello = String::from("こんにちは");
    let hello = String::from("안녕하세요");
    let hello = String::from("你好");
    let hello = String::from("Olá");
    let hello = String::from("Здравствуйте");
    let hello = String::from("Hola");
}

在这种情况下，`len` 将为 4，这意味着存储字符串 “Hola” 的向量长度为 4 个字节。使用 UTF-8 编码时，这些字母中的每一个都占用 1 个字节。但是，以下行可能会让您感到惊讶。（请注意，此字符串以西里尔字母大写字母 Ze 开头，而不是数字 3。）

fn main() {
    let hello = String::from("السلام عليكم");
    let hello = String::from("Dobrý den");
    let hello = String::from("Hello");
    let hello = String::from("שלום");
    let hello = String::from("नमस्ते");
    let hello = String::from("こんにちは");
    let hello = String::from("안녕하세요");
    let hello = String::from("你好");
    let hello = String::from("Olá");
    let hello = String::from("Здравствуйте");
    let hello = String::from("Hola");
}

如果询问字符串的长度，您可能会说 12。实际上，Rust 的答案是 24：这是使用 UTF-8 编码 “Здравствуйте” 所需的字节数，因为该字符串中的每个 Unicode 标量值都需要 2 个字节的存储空间。因此，字符串字节中的索引并不总是与有效的 Unicode 标量值相关联。为了说明这一点，请考虑以下无效的 Rust 代码

let hello = "Здравствуйте";
let answer = &hello[0];

您已经知道 `answer` 不会是第一个字母 `З`。使用 UTF-8 编码时，`З` 的第一个字节是 `208`，第二个字节是 `151`，因此 `answer` 实际上应该是 `208`，但 `208` 本身不是有效的字符。如果用户要求获取此字符串的第一个字母，则返回 `208` 可能不是他们想要的；但是，这是 Rust 在字节索引 0 处拥有的唯一数据。即使字符串仅包含拉丁字母，用户通常也不希望返回字节值：如果 `&"hello"[0]` 是返回字节值的有效代码，则它将返回 `104`，而不是 `h`。

因此，答案是，为了避免返回意外值并导致可能不会立即发现的错误，Rust 根本不会编译此代码，并在开发过程的早期就防止了误解。

字节、标量值和字素簇！我的天啊！

关于 UTF-8 的另一点是，从 Rust 的角度来看，实际上有三种相关的方式来查看字符串：字节、标量值和字素簇（最接近我们所说的*字母*）。

如果我们看一下用梵文书写的印地语单词 “नमस्ते”，它存储为一个 `u8` 值的向量，如下所示

[224, 164, 168, 224, 164, 174, 224, 164, 184, 224, 165, 141, 224, 164, 164,
224, 165, 135]

那是 18 个字节，是计算机最终存储此数据的方式。如果我们将它们视为 Unicode 标量值（即 Rust 的 `char` 类型），则这些字节如下所示

['न', 'म', 'स', '्', 'त', 'े']

这里有六个 `char` 值，但第四个和第六个不是字母：它们是本身没有意义的变音符号。最后，如果我们将它们视为字素簇，我们将得到一个人会称之为构成印地语单词的四个字母

["न", "म", "स्", "ते"]

Rust 提供了不同的方法来解释计算机存储的原始字符串数据，以便每个程序都可以选择它需要的解释，而不管数据使用哪种人类语言。

Rust 不允许我们索引 `String` 来获取字符的最后一个原因是，索引操作预计始终需要固定的时间 (O(1))。但是，使用 `String` 无法保证该性能，因为 Rust 必须从头到尾遍历内容到索引，以确定有多少个有效字符。

切片字符串

索引字符串通常是一个坏主意，因为不清楚字符串索引操作的返回类型应该是什么：字节值、字符、字素簇还是字符串切片。因此，如果您确实需要使用索引来创建字符串切片，Rust 会要求您更加具体。

您可以使用带有范围的 `[]` 来创建包含特定字节的字符串切片，而不是使用带有单个数字的 `[]` 进行索引

#![allow(unused)]
fn main() {
let hello = "Здравствуйте";

let s = &hello[0..4];
}

这里，`s` 将是一个 `&str`，其中包含字符串的前 4 个字节。前面我们提到过，这些字符中的每一个都是 2 个字节，这意味着 `s` 将是 `Зд`。

如果我们尝试使用 `&hello[0..1]` 之类的代码仅对字符字节的一部分进行切片，则 Rust 会在运行时崩溃，就像在向量中访问了无效索引一样

$ cargo run
   Compiling collections v0.1.0 (file:///projects/collections)
    Finished dev [unoptimized + debuginfo] target(s) in 0.43s
     Running `target/debug/collections`
thread 'main' panicked at src/main.rs:4:19:
byte index 1 is not a char boundary; it is inside 'З' (bytes 0..2) of `Здравствуйте`
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

您应该谨慎使用范围来创建字符串切片，因为这样做可能会导致程序崩溃。

迭代字符串的方法

对字符串片段进行操作的最佳方法是明确说明您需要的是字符还是字节。对于单个 Unicode 标量值，请使用 `chars` 方法。对 “Зд” 调用 `chars` 会分离并返回两个 `char` 类型的 value，您可以迭代结果以访问每个元素

#![allow(unused)]
fn main() {
for c in "Зд".chars() {
    println!("{c}");
}
}

此代码将打印以下内容

З
д

或者，`bytes` 方法返回每个原始字节，这可能适合您的域

#![allow(unused)]
fn main() {
for b in "Зд".bytes() {
    println!("{b}");
}
}

此代码将打印构成此字符串的四个字节

208
151
208
180

但请务必记住，有效的 Unicode 标量值可能由多个字节组成。

从字符串中获取字素簇（如梵文）非常复杂，因此标准库不提供此功能。您可以在 crates.io 上找到提供此功能的 crate如果您需要此功能。

字符串并非如此简单

总而言之，字符串很复杂。不同的编程语言对如何向程序员呈现这种复杂性做出了不同的选择。Rust 选择将正确处理 `String` 数据作为所有 Rust 程序的默认行为，这意味着程序员必须预先更多地考虑如何处理 UTF-8 数据。与其他编程语言相比，这种权衡暴露了字符串的更多复杂性，但它可以防止您在开发生命周期的后期处理涉及非 ASCII 字符的错误。

好消息是，标准库提供了许多基于 `String` 和 `&str` 类型构建的功能，可以帮助您正确处理这些复杂情况。请务必查看文档以了解有用的方法，例如用于在字符串中搜索的 `contains` 和用于用另一个字符串替换字符串部分的 `replace`。

让我们切换到一些不太复杂的内容：哈希映射！