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

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

我们讨论字符串时将其放在集合的背景下，因为字符串是作为字节的集合实现的，加上一些方法，当这些字节被解释为文本时提供有用的功能。在这一节中，我们将讨论所有集合类型都有的 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();
}

Listing 8-11: Creating a new, empty 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();
}

Listing 8-12: Using the to_string method to create a String from a string literal

这段代码创建了一个包含 initial contents 的字符串。

我们也可以使用函数String::from从字符串字面量创建一个String。列表 8-13 中的代码等同于使用to_string的列表 8-12 中的代码。

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

Listing 8-13: Using the String::from function to create a String from a string literal

因为字符串被用于许多事情，我们可以为字符串使用许多不同的通用 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");
}

Listing 8-14: Storing greetings in different languages in strings

所有这些都是有效的 String 值。

更新字符串

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

Appending to a String with `push_str` and `push`

我们可以使用 push_str 方法来追加一个字符串切片，从而扩展 String，如清单 8-15 所示。

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

Listing 8-15: Appending a string slice to a String using the push_str method

在这两行之后，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}");
}

Listing 8-16: Using a string slice after appending its contents to a String

如果 push_str 方法获取了 s2 的所有权，我们就无法在最后一行打印它的值。然而，这段代码如我们所期望的那样工作！

push 方法接受一个字符作为参数，并将其添加到 String 中。列表 8-17 使用 push 方法将字母 l 添加到 String 中。

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

Listing 8-17: Adding one character to a String value using push

因此，s 将包含 lol。

Concatenation with the `+` Operator or the `format!` Macro

经常地，你可能想要将两个已有的字符串组合起来。一种方法是使用 + 运算符，如清单 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
}

Listing 8-18: Using the + operator to combine two String values into a new String value

字符串 s3 将包含 Hello, world!。在添加之后 s1 不再有效，以及我们使用 s2 的引用的原因，与调用的方法的签名有关，当我们使用 + 运算符时。 + 运算符使用 add 方法，其签名看起来像这样：

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

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

首先，s2 有一个 &，这意味着我们正在向第一个字符串添加第二个字符串的引用。这是由于 add 函数中的 s 参数：我们只能将一个 &str 添加到一个 String；我们不能将两个 String 值相加。但是等等——&s2 的类型是 &String，而不是 &str，如 add 的第二个参数所指定的。那么为什么示例 8-18 能编译呢？

我们能够在调用 &s2 时使用 add 是因为编译器可以将 &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 的部分，你会得到一个错误。考虑 Listing 8-19 中的无效代码。

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

Listing 8-19: Attempting to use indexing syntax with a String

这段代码将导致以下错误：

$ cargo run
   Compiling collections v0.1.0 (file:///projects/collections)
error[E0277]: the type `str` cannot be indexed by `{integer}`
 --> src/main.rs:3:16
  |
3 |     let h = s1[0];
  |                ^ string indices are ranges of `usize`
  |
  = help: the trait `SliceIndex<str>` is not implemented for `{integer}`, which is required by `String: Index<_>`
  = note: you can use `.chars().nth()` or `.bytes().nth()`
          for more information, see chapter 8 in The Book: <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
  = help: the trait `SliceIndex<[_]>` is implemented for `usize`
  = help: for that trait implementation, expected `[_]`, found `str`
  = note: required for `String` to implement `Index<{integer}>`

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

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

Internal Representation

一个 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 编码中都占用一个字节。然而，下一行可能会让你感到惊讶（注意，这个字符串以大写的西里尔字母 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：这是编码“Здравствуйте”所需的字节数，因为该字符串中的每个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 根本不会编译这段代码，并且在开发过程的早期防止误解。

Bytes and Scalar Values and Grapheme Clusters! Oh My!

关于 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 提供了不同的方式来解释计算机存储的原始字符串数据，以便每个程序可以选择它需要的解释方式，无论数据使用的是哪种人类语言。

不允许我们对 String 进行索引来获取字符的最后一个原因是，索引操作预计总是需要常数时间（O(1)）。但是，由于 Rust 必须从头开始遍历内容到索引位置以确定有多少个有效字符，因此无法保证 String 的这种性能。

字符串切片

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

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

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

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

这里，s 将是一个包含字符串前四个字节的 &str。之前我们提到每个字符都是两个字节，这意味着 s 将是 Зд。

如果我们尝试使用类似&hello[0..1]的方式只切片一个字符的部分字节，Rust 会在运行时像访问向量中的无效索引一样引发恐慌：

$ cargo run
   Compiling collections v0.1.0 (file:///projects/collections)
    Finished `dev` profile [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 的值，你可以遍历结果以访问每个元素：

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

这段代码将打印以下内容：

З
д

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

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

这段代码将打印组成这个字符串的四个字节：

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

从字符串中获取图形单元（grapheme clusters），如天城文（Devanagari）脚本，是复杂的，因此标准库不提供此功能。如果您需要此功能，可以在crates.io 上找到相关的 crate。

字符串并不那么简单

总之，字符串很复杂。不同的编程语言在如何向程序员展示这种复杂性方面做出了不同的选择。Rust 选择使 String 数据的正确处理成为所有 Rust 程序的默认行为，这意味着程序员需要在一开始就更多地考虑处理 UTF-8 数据。这种权衡使字符串的复杂性比其他编程语言中更明显，但它可以防止你在开发生命周期的后期处理涉及非 ASCII 字符的错误。

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

让我们切换到一个稍微简单点的主题：哈希映射！

The Rust Programming Language