Rust Strings Practice: String vs &str, Ownership & Methods

Rule of thumb: take &str for input parameters (accepts both String and literals via deref coercion). Use String when you need ownership or mutation. For a copy-ready reference of all string types and conversions, see the Rust string types cheat sheet.

The most common string error. A struct or function wants an owned String but you passed a literal:

struct Config {
    name: String,
}

// WRONG: "app" is &str, not String
// let c = Config { name: "app" };  // error[E0308]

// RIGHT: convert to String
let c = Config { name: String::from("app") };
// or
let c = Config { name: "app".to_string() };
// or
let c = Config { name: "app".to_owned() };

Rust strings are UTF-8 encoded. A single character can be 1--4 bytes, so s[0] would be ambiguous (byte? character? grapheme?):

// WRONG: direct indexing
// let s = String::from("hello");
// let c = s[0];  // error[E0277]: String cannot be indexed by {integer}

// RIGHT: use .chars() for character access
let s = String::from("hello");
let c = s.chars().nth(0);  // Some('h')

// RIGHT: byte slicing when you know the boundaries
let first_byte = &s[0..1];  // "h" — safe for ASCII

An &str slice borrows the String. The ownership and borrowing rules apply directly here: you cannot mutate the String while the slice is alive:

let mut s = String::from("hello world");

// WRONG: slice borrows s, then we try to mutate
// let first = &s[..5];
// s.push_str("!");  // error[E0502]
// println!("{first}");

// RIGHT: scope the slice, or copy what you need
let first = s[..5].to_string();  // copy into owned String
s.push_str("!");                 // no active borrow
println!("{first}");

&s[a..b] panics if the range lands inside a multi-byte character. Use get() for non-panicking slicing:

let s = "cafe\u{0301}";  // "café" — e + combining accent

// PANICS: byte 5 is inside the combining accent
// let bad = &s[0..5];

// SAFE: get() returns None on invalid boundaries
let safe = s.get(0..4);  // Some("cafe")
let invalid = s.get(0..5);  // None (not a char boundary)

// Check boundaries explicitly
if s.is_char_boundary(4) {
    let slice = &s[0..4];  // "cafe"
}

Make get() your default for any range that comes from user input or computation.

.len() counts bytes, not characters. These three measurements can all differ:

let s = "cafe\u{0301}";  // "café" (e + combining accent)

s.len()              // 6 bytes (UTF-8 encoded)
s.chars().count()    // 5 Unicode scalar values (c, a, f, e, combining accent)
// grapheme clusters: 4 ("c", "a", "f", "é") — need unicode-segmentation crate

For grapheme clusters, use the unicode-segmentation crate: UnicodeSegmentation::graphemes(s, true).count().

// &str → String (three equivalent ways)
let s1 = "hello".to_string();
let s2 = String::from("hello");
let s3 = "hello".to_owned();

// String → &str (deref coercion or explicit)
let owned = String::from("hello");
let borrowed: &str = &owned;          // deref coercion
let also_borrowed = owned.as_str();   // explicit

// Takes &str: accepts both String and &str via deref coercion
fn greet(name: &str) {
    println!("Hello, {name}!");
}

let owned = String::from("world");
greet(&owned);     // String auto-derefs to &str
greet("world");    // &str passed directly

let mut s = String::new();
s.push_str("hello");
s.push(' ');
s.push_str("world");

// format! for complex concatenation (most readable)
let combined = format!("{} {} {}", year, month, day);

For hot loops, pre-reserve capacity and use push_str. If you're building strings from collection data, the iterators guide shows how to chain .map() and .collect::<String>() for the same effect:

let mut buf = String::with_capacity(1024);
for line in lines {
    buf.push_str(line);
    buf.push('\n');
}

For compile-time literal concatenation, use concat!:

const GREETING: &str = concat!("hello", " ", "world");  // &'static str

• The Rust Book: Strings — String vs &str, UTF-8, slicing
• Rust By Example: Strings — practical string patterns
• std::string::String — full method reference
• unicode-segmentation crate — grapheme cluster iteration