Rust: What is the difference between String and &str?

String — owned, heap-allocated, mutable. &str — borrowed, immutable slice of string data.

String:

• Owned type with heap allocation.
• Mutable — you can push, insert, and remove characters.
• Growable and shrinkable.
• Must be freed when the owner goes out of scope.
• Created with String::from(), .to_string(), or .format!().

1let mut s = String::from("hello");
2s.push_str(" world");
3s.push('!');
4println!("{}", s);  // "hello world!"

&str:

• Borrowed reference to string data (slice).
• Immutable — cannot modify the contents.
• Can point to stack, heap, or static memory.
• String literals ("hello") are &str with static lifetime.
• Zero-cost to create — just a pointer + length.

1let s: &str = "hello";           // Static slice
2let owned = String::from("hello");
3let slice: &str = &owned;         // Borrowed slice
4let part: &str = &owned[0..3];    // Partial slice "hel"

When to use:

• Use String when you need to own and modify the string.
• Use &str when you just need to read data (function parameters, slices).
• Use &str in function signatures for maximum flexibility.

Common mistakes:

• Trying to use a String after moving it: let s2 = s1; — s1 is gone.
• Indexing s[0] — strings are UTF-8, use .chars() or .bytes() instead.
• Not understanding that &s on a String gives &String, which auto-derefs to &str.