我如何连接字符串?

当连接字符串时，需要分配内存来存储结果。最简单的方法是String和&str:

fn main() {
let mut owned_string: String = "hello ".to_owned();
let borrowed_string: &str = "world";
    

owned_string.push_str(borrowed_string);
println!("{}", owned_string);
}

这里，我们有一个可以变异的自有字符串。这是有效的，因为它潜在地允许我们重用内存分配。String和String也有类似的情况，如&String 可以解引用为&str。

fn main() {
let mut owned_string: String = "hello ".to_owned();
let another_owned_string: String = "world".to_owned();
    

owned_string.push_str(&another_owned_string);
println!("{}", owned_string);
}

在此之后，another_owned_string是不变的(注意没有mut限定符)。还有另一个变体消耗 String，但不要求它是可变的。这是一个Add特征的实现，它将String作为左边，将&str作为右边:

fn main() {
let owned_string: String = "hello ".to_owned();
let borrowed_string: &str = "world";
    

let new_owned_string = owned_string + borrowed_string;
println!("{}", new_owned_string);
}

注意，owned_string在调用+后不再可访问。

如果我们想要生成一个新的字符串，而两个字符串都不动呢?最简单的方法是使用format!:

fn main() {
let borrowed_string: &str = "hello ";
let another_borrowed_string: &str = "world";
    

let together = format!("{}{}", borrowed_string, another_borrowed_string);


// After https://rust-lang.github.io/rfcs/2795-format-args-implicit-identifiers.html
// let together = format!("{borrowed_string}{another_borrowed_string}");


println!("{}", together);
}

注意，两个输入变量都是不可变的，所以我们知道它们不会被修改。如果我们想对String的任何组合做同样的事情，我们可以使用String也可以被格式化的事实:

fn main() {
let owned_string: String = "hello ".to_owned();
let another_owned_string: String = "world".to_owned();
    

let together = format!("{}{}", owned_string, another_owned_string);


// After https://rust-lang.github.io/rfcs/2795-format-args-implicit-identifiers.html
// let together = format!("{owned_string}{another_owned_string}");
println!("{}", together);
}

不过，你不能用有来使用format!。你可以克隆一串并将另一个字符串追加到新字符串:

fn main() {
let owned_string: String = "hello ".to_owned();
let borrowed_string: &str = "world";
    

let together = owned_string.clone() + borrowed_string;
println!("{}", together);
}

请注意 -我所做的所有类型规范都是多余的-编译器可以推断出这里的所有类型。我添加这些问题只是为了让刚接触Rust的人更清楚，因为我希望这个问题在那群人中很受欢迎!

要将多个字符串连接成一个字符串，并用另一个字符分隔，有几种方法。

我见过的最好的方法是在数组上使用join方法:

fn main() {
let a = "Hello";
let b = "world";
let result = [a, b].join("\n");


print!("{}", result);
}

根据你的用例，你可能更喜欢更多的控制:

fn main() {
let a = "Hello";
let b = "world";
let result = format!("{}\n{}", a, b);


print!("{}", result);
}

我还看到了一些更手动的方法，有些方法避免在这里或那里进行一两次分配。出于可读性的考虑，我认为上面两个就足够了。

我认为concat方法和+也应该在这里提到:

assert_eq!(
("My".to_owned() + " " + "string"),
["My", " ", "string"].concat()
);

还有concat!宏，但仅用于字面量:

let s = concat!("test", 10, 'b', true);
assert_eq!(s, "test10btrue");

在Rust中连接字符串的简单方法

Rust中有各种方法可以连接字符串

第一个方法(使用concat!()):

fn main() {
println!("{}", concat!("a", "b"))
}

上述代码的输出是:

ab

第二个方法(使用push_str()和+操作符):

fn main() {
let mut _a = "a".to_string();
let _b = "b".to_string();
let _c = "c".to_string();


_a.push_str(&_b);


println!("{}", _a);


println!("{}", _a + &_c);
}

上述代码的输出是:

ab

美国广播公司

第三方法(Using format!()):

fn main() {
let mut _a = "a".to_string();
let _b = "b".to_string();
let _c = format!("{}{}", _a, _b);


println!("{}", _c);
}

上述代码的输出是:

ab

请检查并使用生锈的操场进行实验。

串插拼接

更新:截至2021年12月28日，这在Rust 1.58 Beta中可用。你不再需要Rust Nightly build来做字符串插值。(为后人保留答案的其余部分)。

RFC 2795发布2019-10-27: 建议支持隐式参数，以执行许多人所知道的“字符串插值”;——一种将参数嵌入到字符串中以连接它们的方法

RFC: https://rust-lang.github.io/rfcs/2795-format-args-implicit-identifiers.html

最新版本状态: https://github.com/rust-lang/rust/issues/67984 < / p >

在撰写本文时(2020-9-24)，我认为该功能应该在Rust Nightly构建中可用。

这将允许您通过以下简写进行连接:

format_args!("hello {person}")

它等价于:

format_args!("hello {person}", person=person)

还有一种是“如果”;Crate，它提供了自己的字符串插值:

< a href = " https://crates。io /箱/ ifmt noreferrer“rel = > https://crates.io/crates/ifmt < / >

在Rust默认是所有关于MemoryManage和所有权和移动，我们通常不会看到像复制或深度复制因此 如果你试图连接字符串，那么左手边应该类型字符串，这是可增长的，应该是可变类型，右手边可以是正常的字符串字面量，即类型字符串切片

    fn main (){
let mut x = String::from("Hello"); // type String
let y = "World" // type &str
println!("data printing -------> {}",x+y);






}

来自doc的官方声明，这是指向当您尝试使用arthmatic +运算符 < / p >

fn main() {
let a = String::from("Name");
let b = "Pkgamer";
println!("{}",a+b)
}

Concat two String:

fn concat_string(a: String, b: String) -> String {
a + &b
}

Concat two &str:

fn concat_str(a: &str, b: &str) -> String {
a.to_string() + b
}