&str 与 String 区别
核心区别
&str 和 String 是 Rust 中两种最常用的字符串类型。最根本的区别是所有权:String 拥有字符串数据,&str 只是借用一段字符串数据的引用。
| 对比项 | &str | String |
|---|---|---|
| 所有权 | 不拥有数据(借用) | 拥有数据 |
| 存储位置 | 引用的数据可以在只读段、栈或堆 | 数据在堆上 |
| 可变性 | 不可变 | 可以用 mut 修改 |
| 大小(变量本身) | 16 字节(指针 + 长度) | 24 字节(指针 + 长度 + 容量) |
| 增长/缩减 | 不可以 | 可以(push、pop 等) |
| 创建方式 | "字面量" 或从 String 借用 | String::from()、.to_string() |
| Copy trait | 实现了 Copy(引用本身可复制) | 没有(赋值是移动) |
| 生命周期 | 字面量是 'static,其他取决于来源 | 和变量绑定一致 |
rust
fn main() {
// &str:借用,不可变,轻量
let s1: &str = "hello"; // 数据在只读段,生命周期 'static
// String:拥有,可变,堆分配
let mut s2: String = String::from("hello");
s2.push_str(", world"); // 可以修改
println!("&str: {}", s1);
println!("String: {}", s2);
// 大小对比
println!("&str 大小:{} 字节", std::mem::size_of::<&str>()); // 16
println!("String 大小:{} 字节", std::mem::size_of::<String>()); // 24
}内存布局对比
rust
fn main() {
// &str 的内存布局:
// 栈上:[指针(8字节) | 长度(8字节)]
// 指针指向数据所在的位置(只读段、堆或栈)
let literal: &str = "hello";
// literal 的指针 -> 程序只读数据段中的 "hello"
// String 的内存布局:
// 栈上:[指针(8字节) | 长度(8字节) | 容量(8字节)]
// 指针指向堆上分配的缓冲区
let owned: String = String::from("hello");
println!("String 长度:{},容量:{}", owned.len(), owned.capacity());
// 从 String 借用得到 &str
// 这个 &str 指向的是 String 在堆上的数据
let borrowed: &str = &owned;
println!("借用:{}", borrowed);
// String 的容量可以大于长度(预留空间给未来的追加)
let mut s = String::with_capacity(50);
s.push_str("hi");
println!("长度:{},容量:{}", s.len(), s.capacity()); // 长度 2,容量 50
}互相转换
rust
fn main() {
// === &str 转 String(会分配堆内存,复制数据)===
// 方式一:String::from()
let s1: String = String::from("hello");
// 方式二:.to_string()
let s2: String = "hello".to_string();
// 方式三:.to_owned()
let s3: String = "hello".to_owned();
// 方式四:.into()(类型推断自动转换)
let s4: String = "hello".into();
// === String 转 &str(零成本,只是创建引用)===
let owned = String::from("hello");
// 方式一:自动解引用(最常用)
let b1: &str = &owned;
// 方式二:as_str() 方法
let b2: &str = owned.as_str();
// 方式三:切片语法
let b3: &str = &owned[..];
println!("{}, {}, {}, {}", s1, s2, s3, s4);
println!("{}, {}, {}", b1, b2, b3);
}函数参数该用哪个
这是最常见的困惑之一。原则是:函数参数优先用 &str,只有需要拥有所有权时才用 String。
rust
// 推荐:用 &str 作为参数,既能接受字面量也能接受 String 引用
fn greet(name: &str) {
println!("你好,{}!", name);
}
// 需要拥有所有权时才用 String(比如要存到结构体里)
fn set_name(name: String) -> String {
// name 的所有权转移进来了
name
}
// 返回新创建的字符串用 String
fn build_greeting(name: &str) -> String {
format!("你好,{}!", name)
}
fn main() {
// &str 参数:两种都能传
greet("世界"); // 传字面量
greet(&String::from("Rust")); // 传 String 的引用
// String 参数:必须传所有权
let name = String::from("张三");
let name = set_name(name); // name 被移动
// println!("{}", name); // 旧的 name 已经无效
// 返回 String
let greeting = build_greeting("Rust");
println!("{}", greeting);
}结构体字段该用哪个
rust
// 方式一:用 String(拥有数据,最简单,最常用)
struct User {
name: String,
email: String,
}
// 方式二:用 &str(借用数据,需要生命周期标注)
struct UserRef<'a> {
name: &'a str,
email: &'a str,
}
fn main() {
// String 字段:结构体拥有数据,生命周期不用操心
let user = User {
name: String::from("张三"),
email: String::from("zhangsan@example.com"),
};
println!("用户:{}", user.name);
// &str 字段:数据必须比结构体活得长
let name = String::from("李四");
let email = "lisi@example.com";
let user_ref = UserRef {
name: &name,
email,
};
println!("用户:{}", user_ref.name);
// 注意:name 不能在 user_ref 之前被释放
}基本示例
展示在实际代码中如何选择 &str 和 String:
rust
struct Config {
// 配置项需要拥有数据(可能从文件读取,来源不确定)
host: String,
port: u16,
database: String,
}
impl Config {
// 构造函数接受 &str,内部转成 String
// 这样调用者可以传字面量也可以传 String 引用
fn new(host: &str, port: u16, database: &str) -> Self {
Config {
host: host.to_string(),
port,
database: database.to_string(),
}
}
// 返回引用,不需要复制
fn host(&self) -> &str {
&self.host
}
// 拼接连接字符串,返回新的 String
fn connection_string(&self) -> String {
format!("{}:{}/{}", self.host, self.port, self.database)
}
}
// 搜索函数:参数用 &str(只读),返回 String(新创建的数据)
fn find_and_format(data: &[&str], keyword: &str) -> Vec<String> {
data.iter()
.filter(|item| item.contains(keyword))
.map(|item| format!("匹配:{}", item))
.collect()
}
fn main() {
let config = Config::new("localhost", 5432, "mydb");
println!("连接:{}", config.connection_string());
println!("主机:{}", config.host());
let items = vec!["apple pie", "banana", "apple juice", "grape"];
let results = find_and_format(&items, "apple");
for r in &results {
println!("{}", r);
}
}常见问题
问题一:什么时候用 &str,什么时候用 String?
| 场景 | 推荐类型 | 理由 |
|---|---|---|
| 函数参数(只读) | &str | 通用性好,避免不必要的复制 |
| 函数返回新字符串 | String | 需要拥有数据 |
| 结构体字段 | String | 简单,不用处理生命周期 |
| 常量/静态配置 | &'static str | 编译期确定,零开销 |
| 需要修改内容 | String | &str 不可变 |
| 临时处理/匹配 | &str | 不需要拥有 |
问题二:&str 到 String 的转换有性能开销吗?
有。每次从 &str 转 String 都会在堆上分配内存并复制数据。如果只是读取不修改,应该直接用 &str。
问题三:String 到 &str 的转换有开销吗?
没有。从 String 借用得到 &str 只是创建一个指针和长度,不涉及内存分配或数据复制,是零成本操作。
问题四:为什么 String 不实现 Copy?
因为 String 在堆上有数据。如果允许 Copy(按位复制),就会有两个 String 指向同一块堆内存,释放时会重复释放(double free)。所以 String 只能移动(move)或显式克隆(clone)。
适用场景
&str适合:函数参数、模式匹配、编译期常量、临时字符串处理String适合:结构体字段、函数返回值、需要修改的字符串、从外部输入读取的数据
注意事项
- 函数参数优先用
&str,这是 Rust 社区的普遍约定 - 不要为了"方便"到处用
String,不必要的堆分配会影响性能 - 也不要为了"零开销"强行在结构体中用
&str,生命周期标注会让代码复杂很多 &str到String有四种写法(from、to_string、to_owned、into),功能一样,选一种统一用就行- 接受字符串参数的泛型写法是
fn foo(s: impl AsRef<str>),但初学阶段用&str就够了 format!宏总是返回String
总结
&str 和 String 的核心区别是所有权:&str 借用数据,String 拥有数据。函数参数优先用 &str(通用性好,零开销借用),需要拥有数据时用 String(结构体字段、返回值、需要修改内容)。从 &str 到 String 会分配堆内存并复制数据,从 String 到 &str 是零成本引用。在日常开发中,合理选择这两种类型是写出高效、清晰 Rust 代码的基础。