字符串字面量 &str
什么是 &str
&str(读作 "string slice")是 Rust 中最基础的字符串类型,它是对一段 UTF-8 编码字节序列的不可变引用。当你在代码中写 "hello" 这样的字符串字面量时,它的类型就是 &str。
字符串字面量被直接嵌入到编译后的二进制文件中,在程序运行期间一直存在,所以它的完整类型其实是 &'static str——生命周期为整个程序的字符串切片。
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。字符串字面量的数据存储在程序的只读数据段中。
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]
}字符串字面量的特殊语法
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 的常用方法
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 的引用。
// 接受 &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));
}基本示例
简单的文本分析:
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 有什么区别?
| 对比项 | &str | String |
|---|---|---|
| 所有权 | 借用(不拥有数据) | 拥有数据 |
| 存储位置 | 只读数据段/栈/堆(取决于来源) | 堆 |
| 可变性 | 不可变 | 可以用 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() 是字节长度、不能用索引直接访问字符、切片必须在字符边界切割。