String vs &str

String

• Owned by the variable, meaning the variable controls the memory.

• Can be mutated.

• Ideal for strings whose size can change or need to persist beyond the scope of their original reference.

&str

• Borrowed, immutable string slice.

• Represents a view into a string, rather than owning the data.

• Usually refers to a segment of a String or a string literal.

• Immutable by default.

Conversions Between String and &str

Convert &str to String: Use the to_string or String::from methods.

let slice: &str = "Hello";
let owned: String = slice.to_string();
let owned2: String = String::from(slice);

Convert String to &str: Borrow a string using & or .as_str().

let owned: String = String::from("Hello");
let slice: &str = &owned;
let slice2: &str = owned.as_str();

Examples

fn main() {
    let x = "hello ";
    println!("\"{}\"", x.trim()); // ok
    println!("\"{}\"", x + "world"); // error
}

• In above example the x.trim function will work because it doesn't manipulate the string.

• Instead it return a slice of original string.

• But x + "world" got compile error because you cannot mutate the variable x: &str.

fn main() {
    let x = "hello ".to_string();
    println!("\"{}\"", x + "world"); // ok
}

• Above example will work because x is converted to String and can be mutated.

• In other words, any function or method that manipulate the value will not work using &str but will work using String type.

References

• https://doc.rust-lang.org/book/ch08-02-strings.html#what-is-a-string