字符串字面量 &str ​

什么是 &str ​

&str(读作 "string slice")是 Rust 中最基础的字符串类型,它是对一段 UTF-8 编码字节序列的不可变引用。当你在代码中写 "hello" 这样的字符串字面量时,它的类型就是 &str。

字符串字面量被直接嵌入到编译后的二进制文件中,在程序运行期间一直存在,所以它的完整类型其实是 &'static str——生命周期为整个程序的字符串切片。

rust
fn main() {
    // 字符串字面量的类型是 &str
    let greeting: &str = "Hello, World!";
    let chinese: &str = "你好,世界!";
    let emoji: &str = "🦀 Rust";

    println!("{}", greeting);
    println!("{}", chinese);
    println!("{}", emoji);

    // &str 是胖指针:指针 + 长度
    println!("&str 大小:{} 字节", std::mem::size_of::<&str>());  // 16
}

&str 的内存布局 ​

&str 在内存中由两部分组成:一个指向字节数据起始位置的指针,和一个表示字节长度的 usize。字符串字面量的数据存储在程序的只读数据段中。

rust
fn main() {
    let s: &str = "hello";

    // .len() 返回的是字节数,不是字符数
    println!("'hello' 的字节长度:{}", s.len());  // 5

    // 中文字符在 UTF-8 中占 3 个字节
    let zh: &str = "你好";
    println!("'你好' 的字节长度:{}", zh.len());  // 6(每个中文 3 字节)
    println!("'你好' 的字符数:{}", zh.chars().count());  // 2

    // 查看底层字节
    println!("'hello' 的字节:{:?}", s.as_bytes());  // [104, 101, 108, 108, 111]
    println!("'你好' 的字节:{:?}", zh.as_bytes());   // [228, 189, 160, 229, 165, 189]
}

字符串字面量的特殊语法 ​

rust
fn main() {
    // 转义字符
    let escaped = "第一行\n第二行\t带制表符";
    println!("{}", escaped);

    // 反斜杠和引号的转义
    let path = "C:\\Users\\admin";
    let quoted = "他说:\"你好\"";
    println!("{}", path);
    println!("{}", quoted);

    // 原始字符串(raw string):r"..." 不处理转义
    let raw = r"C:\Users\admin\no\escape";
    println!("{}", raw);  // C:\Users\admin\no\escape

    // 原始字符串中需要包含引号时,用 r#"..."#
    let raw_with_quotes = r#"他说:"你好""#;
    println!("{}", raw_with_quotes);

    // 多个 # 号用于包含 "# 的情况
    let complex = r##"包含 "# 的字符串"##;
    println!("{}", complex);

    // 多行字符串
    let multiline = "第一行
第二行
第三行";
    println!("{}", multiline);

    // 多行字符串,续行(行末 \ 表示下一行紧接着)
    let continued = "这是一行很长的字符串,\
                     用反斜杠续行可以\
                     在源码中换行但输出不换行";
    println!("{}", continued);

    // 字节字符串:b"..." 类型是 &[u8; N]
    let byte_str: &[u8; 5] = b"hello";
    println!("字节字符串:{:?}", byte_str);
}

&str 的常用方法 ​

rust
fn main() {
    let s = "  Hello, Rust World!  ";

    // 去除首尾空白
    println!("trim: '{}'", s.trim());              // 'Hello, Rust World!'
    println!("trim_start: '{}'", s.trim_start());  // 'Hello, Rust World!  '
    println!("trim_end: '{}'", s.trim_end());      // '  Hello, Rust World!'

    let text = "Hello, Rust World!";

    // 大小写转换(返回新的 String)
    println!("大写:{}", text.to_uppercase());  // HELLO, RUST WORLD!
    println!("小写:{}", text.to_lowercase());  // hello, rust world!

    // 查找和包含
    println!("包含 Rust:{}", text.contains("Rust"));     // true
    println!("以 Hello 开头:{}", text.starts_with("Hello")); // true
    println!("以 ! 结尾:{}", text.ends_with("!"));       // true
    println!("Rust 的位置:{:?}", text.find("Rust"));     // Some(7)

    // 替换(返回新的 String)
    println!("替换:{}", text.replace("Rust", "世界"));

    // 分割
    let csv = "apple,banana,orange,grape";
    let fruits: Vec<&str> = csv.split(',').collect();
    println!("水果:{:?}", fruits);

    // 判断是否为空
    println!("是否为空:{}", "".is_empty());     // true
    println!("是否为空:{}", " ".is_empty());    // false(有空格)

    // 重复
    println!("{}", "ha".repeat(3));  // "hahaha"
}

&str 作为函数参数 ​

&str 是函数接受字符串参数的首选类型,因为它既能接受字符串字面量也能接受 String 的引用。

rust
// 接受 &str 参数:既能传字面量也能传 String 的引用
fn greet(name: &str) {
    println!("你好,{}!", name);
}

fn count_words(text: &str) -> usize {
    text.split_whitespace().count()
}

fn main() {
    // 传字符串字面量
    greet("世界");

    // 传 String 的引用(自动解引用为 &str)
    let name = String::from("Rust");
    greet(&name);

    let text = "Rust is a systems programming language";
    println!("单词数:{}", count_words(text));

    let owned_text = String::from("Hello World");
    println!("单词数:{}", count_words(&owned_text));
}

基本示例 ​

简单的文本分析:

rust
fn analyze_text(text: &str) {
    println!("文本:{}", text);
    println!("字节长度:{}", text.len());
    println!("字符数:{}", text.chars().count());
    println!("单词数:{}", text.split_whitespace().count());
    println!("行数:{}", text.lines().count());

    // 统计各类字符
    let letters = text.chars().filter(|c| c.is_alphabetic()).count();
    let digits = text.chars().filter(|c| c.is_numeric()).count();
    let spaces = text.chars().filter(|c| c.is_whitespace()).count();

    println!("字母:{} 个", letters);
    println!("数字:{} 个", digits);
    println!("空白:{} 个", spaces);
}

fn main() {
    let sample = "Hello World 2026!\n你好世界!\nRust Programming";
    analyze_text(sample);
}

常见问题 ​

问题一:&str 和 String 有什么区别?

对比项&strString
所有权借用(不拥有数据)拥有数据
存储位置只读数据段/栈/堆(取决于来源)堆
可变性不可变可以用 mut 修改
大小固定 16 字节(胖指针)24 字节(指针+长度+容量)
创建方式"字面量" 或从 String 借用String::from()、.to_string()
适合场景函数参数、只读访问需要拥有和修改字符串时

问题二:为什么 .len() 返回字节数不是字符数?

因为 &str 的底层是 UTF-8 字节序列,.len() 返回的是这个序列的字节长度。不同字符占用的字节数不同(ASCII 1 字节,中文 3 字节,emoji 4 字节),所以字节数和字符数通常不相等。要获取字符数用 .chars().count()。

问题三:&str 可以修改吗?

&str 本身是不可变引用,不能修改。所有"修改"操作(如 replace、to_uppercase)都会返回一个新的 String,不会改变原始数据。如果需要可变字符串,用 String。

问题四:字符串字面量存储在哪里?

字符串字面量的数据被编译到程序的只读数据段(.rodata),程序启动后就一直存在。它的生命周期是 'static,比任何变量都长。

适用场景 ​

  • 函数参数:fn process(text: &str) 是接受字符串最通用的方式
  • 配置常量:const NAME: &str = "MyApp";
  • 模式匹配:match command { "start" => ..., "stop" => ... }
  • 字符串搜索和分析:查找、包含、分割等只读操作
  • 和其他语言交互中的字符串传递:零拷贝传递字符串引用

注意事项 ​

  • &str 的 .len() 返回字节数不是字符数
  • 不能用 s[0] 这样的索引访问 &str 中的字符(因为 UTF-8 是变长编码)
  • 字符串切片的范围索引(&s[0..3])必须落在 UTF-8 字符边界上
  • &str 保证是合法的 UTF-8 编码,不需要额外验证
  • 字符串字面量的生命周期是 'static,在整个程序运行期间都有效
  • 大多数接受字符串的函数应该用 &str 而不是 String 作为参数类型

总结 ​

&str 是 Rust 中最基本的字符串类型,是对 UTF-8 编码字节序列的不可变引用。字符串字面量("hello")的类型就是 &'static str,数据存储在程序的只读数据段中。&str 由指针和长度两部分组成,是零成本的引用——不涉及数据复制。在写函数时,优先用 &str 作为字符串参数类型,这样既能接受字面量也能接受 String 的引用。操作 &str 时要记住 .len() 是字节长度、不能用索引直接访问字符、切片必须在字符边界切割。