字符串

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：文本分段