字符串类型

在Rust中有两种字符串类型：

fn main() {
    let s1: &str = "World";
    println!("s1: {s1}");

    let mut s2: String = String::from("Hello ");
    println!("s2: {s2}");
    s2.push_str(s1);
    println!("s2: {s2}");

    let s3: &str = &s2[6..];
    println!("s3: {s3}");
}

那这两种字符串有什么区别呢？在java中好像有一个stringbuild差不多的方式去动态修改字符串。你可以类比的理解这个概念。

&str一个对字符串切片的不可变引用。
String一个可变的字符串缓冲区。

如果你想修改字符串的内容，你应该选择String来定义你的字符串。

我们在看一个例子：

let a = "hello world";
let b = "OK";
let mut s = String::from("Hello Rust");
println!("{}", s.capacity());    // prints 12
s.push_str("Here I come!");
println!("{}", s.len()); // prints 24
let s = "Hello, Rust!";
println!("{}", s.capacity()); // compile error: no method named `capacity` found for type `&str`
println!("{}", s.len()); // prints 12

String保留了一个len()和capacity()，但str只有一个len()。
&str 是 str的一个的borrowed 类型，可以称为一个字符串切片，一个不可变的string。

关于&String

&String 是String的borrowed类型，这只不过是一个指针类型，可以传递而不放弃ownership。事实上，一个&String可以当做是&str。

fn main() {
    let s = String::from("Hello, Rust!");
    foo(&s);
}
fn foo(s: &str) {
    println!("{}", s);
}

foo()可以使用string slice或者borrowed String类型。

如果我们想修改字符串的内容，只需要传递一个可变引用就行了。

fn main() {
    let mut s = String::from("Hello, Rust!");
    foo(&mut s);
}
fn foo(s: &mut String) {
    s.push_str("appending foo..");
    println!("{}", s);
}

相互转换

&str => String

let c = a.to_string();
let d = String::from(b);
let d = a.to_owned();

String => &str

let e = &String::from("Hello Rust");
// 或使用as_str()
let e_tmp = String::from("Hello Rust");
let e = e_tmp.as_str();
// 不能直接这样使用 
// let e = String::from("Hello Rust").as_str();

String + &str => String

String后面接上N个&str

let mut strs = "Hello".to_string();
// let mut strs = String::from("Hello");
strs.push_str(" Rust");
println!("{}", strs);

总结

如果只想要一个字符串的只读视图，或者&str作为一个函数的参数，那就首选&str。如果想拥有所有权，想修改字符串那就用String吧。

微信搜索梦兽编程公众号

参考资料

[1]

google.github.io/comprehensi…: google.github.io/comprehensi…

本文使用 markdown.com.cn 排版

跟着谷歌安卓团队学Rust - String vs str