&str 与 String 区别 ​

核心区别 ​

&str 和 String 是 Rust 中两种最常用的字符串类型。最根本的区别是所有权:String 拥有字符串数据,&str 只是借用一段字符串数据的引用。

对比项&strString
所有权不拥有数据(借用)拥有数据
存储位置引用的数据可以在只读段、栈或堆数据在堆上
可变性不可变可以用 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 代码的基础。