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

简介

欢迎来到「使用字符串存储 UTF-8 编码文本」实验。本实验是 Rust 程序设计语言 的一部分。你可以在 LabEx 中练习 Rust 技能。

在本实验中，我们将讨论 Rust 中字符串的复杂性，特别是与 UTF-8 编码相关的内容，以及 String 类型与其他集合相比的操作和差异。

Skills Graph

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

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

我们在集合的背景下讨论字符串，因为字符串被实现为字节的集合，再加上一些在将这些字节解释为文本时提供有用功能的方法。在本节中，我们将讨论每个集合类型都有的对 String 的操作，例如创建、更新和读取。我们还将讨论 String 与其他集合的不同之处，即由于人和计算机对 String 数据的解释方式不同，对 String 进行索引会变得很复杂。

什么是字符串？

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

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

创建新字符串

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

let mut s = String::new();

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

这行代码创建了一个名为 s 的新的空字符串，之后我们可以向其中加载数据。通常，我们会有一些初始数据来开始构建字符串。为此，我们使用 to_string 方法，任何实现了 Display 特性的类型都有这个方法，就像字符串字面值一样。清单 8-12 展示了两个示例。

let data = "initial contents";

let s = data.to_string();

// 该方法也可以直接用于字面值：
let s = "initial contents".to_string();

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

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

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

let s = String::from("initial contents");

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

因为字符串用途广泛，所以我们可以对字符串使用许多不同的通用 API，这为我们提供了很多选择。其中一些可能看起来有些冗余，但它们都有各自的用途！在这种情况下，String::from 和 to_string 做的是相同的事情，所以选择哪一个只是风格和可读性的问题。

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

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 值。

更新字符串

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

使用 push_str 和 push 向字符串追加内容

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

let mut s = String::from("foo");
s.push_str("bar");

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

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

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 方法向一个 String 添加字母 “l”。

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

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

结果，s 将包含 “lol”。

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

通常，你会想要将两个现有的字符串组合起来。一种方法是使用 + 运算符，如清单 8-18 所示。

let s1 = String::from("Hello, ");
let s2 = String::from("world!");
let s3 = s1 + &s2; // 注意，s1 在这里已经被移动，不能再使用

清单 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 内容的一个副本，然后返回结果的所有权。换句话说，它看起来像是在进行大量复制，但实际上不是；其实现比复制更高效。

如果我们需要拼接多个字符串，+ 运算符的行为会变得很麻烦：

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! 宏：

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 中的无效代码。

let s1 = String::from("hello");
let h = s1[0];

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

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

error[E0277]: the type `String` cannot be indexed by `{integer}`
 --> src/main.rs:3:13
  |
3 |     let h = s1[0];
  |             ^^^^^ `String` cannot be indexed by `{integer}`
  |
  = help: the trait `Index<{integer}>` is not implemented for
`String`

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

内部表示

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

let hello = String::from("Hola");

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

let hello = String::from("Здравствуйте");

如果你被问到这个字符串有多长，你可能会说 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 要求你更明确一些。

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

let hello = "Здравствуйте";

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

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

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

thread'main' panicked at 'byte index 1 is not a char boundary;
it is inside 'З' (bytes 0..2) of `Здравствуйте`', src/main.rs:4:14

在使用范围创建字符串切片时你应该小心，因为这样做可能会使你的程序崩溃。

遍历字符串的方法

处理字符串片段的最佳方法是明确你想要的是字符还是字节。对于单个 Unicode 标量值，使用 chars 方法。对 “Зд” 调用 chars 会将其分开并返回两个 char 类型的值，你可以遍历结果来访问每个元素：

for c in "Зд".chars() {
    println!("{c}");
}

这段代码将输出：

З
д

或者，bytes 方法返回每个原始字节，这可能适合你的应用场景：

for b in "Зд".bytes() {
    println!("{b}");
}

这段代码将输出组成这个字符串的四个字节：

208
151
208
180

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

从字符串中获取字形簇，比如对于天城体文字，是很复杂的，所以标准库没有提供此功能。如果你需要此功能，可以在 https://crates.io 上找到相关的 crate。

字符串并非那么简单

总结一下，字符串很复杂。不同的编程语言对于如何向程序员呈现这种复杂性做出了不同的选择。Rust 选择将正确处理 String 数据作为所有 Rust 程序的默认行为，这意味着程序员必须在前期更加深入地思考如何处理 UTF-8 数据。这种权衡使得字符串的复杂性比其他编程语言中更为明显，但它能防止你在开发生命周期的后期不得不处理涉及非 ASCII 字符的错误。

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

让我们转向稍微不那么复杂的内容：哈希映射！

总结

恭喜你！你已经完成了“使用字符串存储 UTF-8 编码文本”实验。你可以在 LabEx 中练习更多实验来提升你的技能。