How do I concatenate strings?

by

When you concatenate strings, you need to allocate memory to store the result. The easiest to start with is String and &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);
}

Here, we have an owned string that we can mutate. This is efficient as it potentially allows us to reuse the memory allocation. There’s a similar case for String and String, as &String can be dereferenced as &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);
}

After this, another_owned_string is untouched (note no mut qualifier). There’s another variant that consumes the String but doesn’t require it to be mutable. This is an implementation of the Add trait that takes a String as the left-hand side and a &str as the right-hand side:

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

Note that owned_string is no longer accessible after the call to +.

What if we wanted to produce a new string, leaving both untouched? The simplest way is to use 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);
}

Note that both input variables are immutable, so we know that they aren’t touched. If we wanted to do the same thing for any combination of String, we can use the fact that String also can be formatted:

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

You don’t have to use format! though. You can clone one string and append the other string to the new string:

fn main() {
    let owned_string: String = "hello ".to_owned();
    let borrowed_string: &str = "world";
    
    let together = owned_string.clone() + borrowed_string;
    println!("{}", together);
}

Note – all of the type specification I did is redundant – the compiler can infer all the types in play here. I added them simply to be clear to people new to Rust, as I expect this question to be popular with that group!

More Related Contents:

  1. I want to run a loop in println [duplicate]
  2. Why is it discouraged to accept a reference to a String (&String), Vec (&Vec), or Box (&Box) as a function argument?
  3. Why does my string not match when reading user input from stdin?
  4. What are the differences between Rust’s `String` and `str`?
  5. Making a string concatenation operator in R
  6. How to match a String against string literals?
  7. How to efficiently concatenate strings in go
  8. What does “`str` does not have a constant size known at compile-time” mean, and what’s the simplest way to fix it?
  9. How do I convert a Vec to Vec?
  10. How do I concatenate strings in Swift?
  11. Why is capitalizing the first letter of a string so convoluted in Rust?
  12. Convert Vec into a slice of &str in Rust?
  13. How does the lifetime work on constant strings / string literals?
  14. How to concatenate strings with padding in sqlite
  15. How do I convert between String, &str, Vec and &[u8]?
  16. How to collapse a list of characters into a single string in R
  17. How do I make format! return a &str from a conditional expression?
  18. Is there an owned version of String::chars?
  19. How can I use a dynamic format string with the format! macro?
  20. How to create a formatted String out of a literal in Rust?
  21. What is the equivalent of the join operator over a vector of Strings?
  22. Python Pandas concatenate a Series of strings into one string
  23. How to index a String in Rust
  24. Efficiently repeat a character/string n times in Scala
  25. What is the difference between VBScript’s + and & operator?
  26. Can I convert a string to enum without macros in Rust?
  27. Getting “command not found” error while comparing two strings in Bash
  28. Removing html tags from a string in R
  29. Check whether a string contains a substring
  30. String concatenation vs. string substitution in Python

Leave a Comment