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

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

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

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

当连接字符串时，需要分配内存来存储结果。最简单的开头是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限定符)。还有另一种变体使用字符串，但不要求它是可变的。这是Add trait的一个实现，它将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在调用+后不再可访问。

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

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);
}

你不必使用格式!虽然。你可以克隆一个字符串并将另一个字符串附加到新字符串:

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);
}

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

从Rust 1.58开始，你还可以像这样连接两个或多个变量:format!("{a}{b}{c}")。这与格式基本相同!("{}{}{}"， a, b, c)，但更短一点，(可以说)更容易阅读。这些变量可以是String， &str(也可以是其他非字符串类型)。结果是一个字符串。 更多信息请看这个。

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

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

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



}

来自doc的官方声明，这是指向当你尝试使用arthmatic +运算符