字符串

是什么，为什么存在

Rust 的核心字符串类型是 String 和 str。String 拥有一段堆上的、可增长的 UTF-8 字节序列；str 是动态大小的 字符串切片（string slice） 类型，表示一段有效的 UTF-8 字节。因为裸 str 的大小要到运行时才能确定，所以通常通过 &str、Box<str> 或 Arc<str> 等指针使用它。

最常见的组合是拥有型 String 与借用型 &str。String 负责分配、增长和释放缓冲区，&str 只描述其中一段连续文本，不负责释放。这样的 借用（borrowing） 让函数读取调用方的文本，而不用先复制一份。

字符串字面量的类型也是 &str，但它通常借用程序二进制中的静态数据。由 String 取得的 &str 则可能指向堆缓冲区。存储位置不是字符串类型本身的定义，所有权与 UTF-8 不变量才是关键。

你会在函数参数、解析器、日志消息、协议字段和用户输入中遇到这些类型。选择哪一个取决于 API 是否需要保留输入、是否要修改长度，以及输入是否保证是 UTF-8，而不是取决于文本看起来像不像普通 ASCII。

String 与 str 都保证内容是有效 UTF-8。文件名、C 字符串和任意网络载荷未必满足这个条件，应分别考虑 Path／OsStr、CStr 或字节切片。强行做有损转换会改变数据，不能只为了让类型匹配而使用。

工作原理

所有权与借用视图

String 管理缓冲区的指针、字节长度和容量。把一个 String 赋给另一个变量时，默认发生 移动语义（move semantics） ：缓冲区所有权转移，旧变量不再可用。只有显式调用 clone() 才会复制其中的字节。

从 String 借用 &str 不会复制文本。借用保存数据地址与字节长度，可以覆盖整个字符串，也可以只覆盖一个合法子区间。共享借用还在使用时，Rust 不允许可能使缓冲区重分配的可变操作，因此引用不会在 push_str() 之后悄悄悬空。

这张图描述的是概念关系，不是可依赖的外部 ABI。String 拥有堆缓冲区，&str 只是指向有效 UTF-8 区间的视图。借用的生命周期保证视图不会比它引用的数据活得更久。

UTF-8 与三种计数

UTF-8 使用一到四个字节编码一个 Unicode 标量值。str::len() 返回字节数，chars() 迭代 Unicode 标量值（Unicode scalar value） ，而用户眼中的一个字符可能是由多个标量值组成的 字素簇（grapheme cluster） 。这三种单位不能互换。

例如，é 可以是单个标量值 U+00E9，也可以由 e 与组合重音 U+0301 组成。两段文本看起来相同，字节和标量值数量却可能不同。Rust 标准库不自动做 Unicode 规范化，也不提供完整的字素簇分段。

范围切片使用字节偏移，并要求起点与终点都位于 UTF-8 字符边界。&text[a..b] 在边界不合法时会 panic；text.get(a..b) 会返回 None。char_indices() 同时给出合法字节偏移和对应标量值，适合把字符扫描结果交给后续切片操作。

分配与修改

String::new() 创建空字符串，第一次增长前通常不需要分配。String::with_capacity(n) 预留至少 n 个字节，适合已经知道大致输出大小的构建过程。容量是实现为后续增长保留的空间，不属于字符串内容，len() 永远只报告当前有效字节。

push() 追加一个 char，push_str() 追加一个 &str。insert()、remove()、truncate() 和 replace_range() 接收字节位置，其中涉及的位置必须是字符边界。安全 API 会维护 UTF-8 不变量，但不保证每个运行时位置都有效。

String + &str 会移动左侧 String，然后把右侧内容追加进去。它适合明确消费左值的一次拼接；如果之后还要使用所有输入，format!() 或显式构建新的 String 更清楚。循环构建内容时，复用一个缓冲区通常也更容易表达所有权。

示例

借用输入，返回拥有型结果

这个函数只在调用期间读取姓名，所以参数使用 &str。返回值需要在函数结束后继续存在，因此返回新建的 String。

greeting(&owned) 通过解引用强制转换把 &String 当作 &str 使用，字符串字面量则直接是 &str。两次调用都只借用输入，所以最后仍能读取 owned。预分配按字节计算，正好对应最终要追加的两段 UTF-8 文本。

如果函数要把姓名存进返回的结构体，接收 String 或 impl Into<String> 可能更合适。参数类型应表达所有权契约，而不是一律追求最泛化的签名。

查看 UTF-8 边界

这个例子同时打印字节数、标量值数量和每个标量值的起始字节偏移。两个 get() 调用只差一个起点，却分别成功和失败。

fn main() {
    let text = "Aé中👋";

    println!("bytes: {}", text.len());
    println!("scalars: {}", text.chars().count());

    for (byte_offset, scalar) in text.char_indices() {
        println!("{byte_offset}: {scalar}");
    }

    println!("1..3: {:?}", text.get(1..3));
    println!("2..3: {:?}", text.get(2..3));

    let decomposed = "e\u{301}";
    println!(
        "decomposed bytes/scalars: {}/{}",
        decomposed.len(),
        decomposed.chars().count()
    );
}

bytes: 10
scalars: 4
0: A
1: é
3: 中
6: 👋
1..3: Some("é")
2..3: None
decomposed bytes/scalars: 3/2

é 占据字节区间 1..3，所以该范围能产生 &str。偏移 2 落在它的编码内部，get(2..3) 因此返回 None。组合形式 e\u{301} 有两个标量值和三个字节，但界面可能把它显示为一个字素簇。

如果业务要求「最多 20 个用户可见字符」，chars().take(20) 仍不一定正确，因为它按标量值截断。此时需要明确采用 Unicode 字素簇分段规则，并决定是否先做规范化。

预估容量并在合法边界修改

路径构建器先计算所有部分和分隔符的总字节数，再复用一个缓冲区。后半段使用 find() 返回的匹配起点进行替换；成功匹配 &str 得到的位置一定落在字符边界上。

fn join_path(parts: &[&str]) -> String {
    let separators = parts.len().saturating_sub(1);
    let byte_len = parts.iter().map(|part| part.len()).sum::<usize>() + separators;
    let mut path = String::with_capacity(byte_len);

    for (index, part) in parts.iter().enumerate() {
        if index > 0 {
            path.push('/');
        }
        path.push_str(part);
    }

    path
}

fn main() {
    let path = join_path(&["用户", "42", "settings"]);
    println!("{path}");
    println!("bytes: {}", path.len());

    let mut status = String::from("状态: ready");
    let start = status.find("ready").expect("marker is present");
    status.replace_range(start.., "done");
    println!("{status}");
}

用户/42/settings
bytes: 18
状态: done

容量计算使用 len() 是正确的，因为分配器关心字节，不关心显示字符数。saturating_sub(1) 让空切片的分隔符数量保持为零。若构建器的输入规模无法预估，直接从 String::new() 开始也正确，只是增长时可能需要重新分配。

这里的 replace_range(start.., "done") 改变了字节长度，因此只能作用于 String，不能作用于 &mut str。替换完成后，String 仍然保存有效 UTF-8。

从输入中返回借用字段

解析器不需要改写字段，也不需要让结果脱离原始记录，所以它直接返回指向输入的两个 &str。split_once() 与 trim() 都能产生借用视图，不会为字段创建新的 String。

fn parse_record(line: &str) -> Option<(&str, &str)> {
    let (key, value) = line.split_once('=')?;
    let key = key.trim();
    let value = value.trim();

    if key.is_empty() {
        return None;
    }

    Some((key, value))
}

fn main() {
    for line in ["color = blue", " retries=3 ", " = missing"] {
        match parse_record(line) {
            Some((key, value)) => println!("{key} -> {value}"),
            None => println!("invalid: {line:?}"),
        }
    }
}

color -> blue
retries -> 3
invalid: " = missing"

返回类型中的两个引用由生命周期省略规则关联到唯一的输入引用。调用方持有字段期间，不能销毁或以冲突方式修改原始 line。若字段要进入比输入活得更久的配置对象，就应在该所有权边界调用 to_owned()。

这个实现只把缺少分隔符或空键视为无效，允许空值。真实解析器应在签名和测试中明确这些规则；Option 只能表示成功或失败，需要错误原因时应改用 Result。

陷阱

把字节数当作字符数

修复： 先写清业务单位。协议长度、容量和磁盘大小通常按字节；码点处理可用 chars()；光标移动、删除「一个字符」和长度限制通常需要字素簇分段。不要把一种计数改名后冒充另一种。

用任意范围切片

修复： 如果偏移来自不可信输入，使用 get() 处理 None。如果范围来自文本扫描，保留 char_indices()、find() 或匹配 API 给出的字节边界。按标量值或字素簇截断时，应先迭代目标单位，再转换成字节范围。

为只读 API 强制取得所有权

修复： 普通只读参数使用 &str。函数需要把文本存起来、交给其他所有者或返回独立值时再接收或创建 String。impl AsRef<str> 会增加泛型表面积，只有确实需要接受多种包装类型时才使用。

借用期间增长原字符串

修复： 调整操作顺序，让共享借用在修改前结束；或者先保存拥有型结果，再修改原字符串。不要用不安全指针绕过错误。编译器阻止的是可能悬空的视图，不是无意义的语法偏好。

把小写转换当作完整文本比较

修复： 先定义比较契约。ASCII 协议字段可使用 eq_ignore_ascii_case()；面向自然语言的搜索、排序和去重需要选定规范化、大小写折叠与区域规则。标准库不会替你决定这些产品语义。

延伸阅读

• Rust 程序设计语言：用字符串存储 UTF-8 编码的文本
• Rust 标准库：String
• Rust 标准库：str
• Rust 参考：指针与引用布局
• Unicode 标准附录 #29：文本分段