Rust Strings

Text handling is one of the first places Rust feels different from other languages, mostly because it actually has two string types. Once you know why, it stops being confusing.

&str vs String

• &str (“string slice”) — text that already exists somewhere, usually written directly in your code. Fixed size, can’t grow.
• String — an owned, growable piece of text. You can add to it, and it lives on the heap.

fn main() {
    let literal: &str = "hello";           // a string slice
    let owned: String = String::from("hello"); // an owned String

    println!("{literal} / {owned}");
}

▶ Try it Yourself

A simple rule of thumb: if you’re just printing fixed text, "like this" (a &str) is fine. If you need to build, grow, or modify text at runtime, reach for String.

Growing a String

fn main() {
    let mut greeting = String::from("Hello");
    greeting.push_str(", World"); // add a &str
    greeting.push('!');           // add a single char

    println!("{greeting}");
}

Output:

Hello, World!

▶ Try it Yourself

Combining strings

You can join strings with +, or use format! (which is usually the clearer option):

fn main() {
    let first = String::from("Hello, ");
    let second = String::from("World!");

    let combined = first + &second; // note the & before second
    println!("{combined}");

    // format! is often easier to read:
    let name = "Ferris";
    let greeting = format!("Hello, {name}!");
    println!("{greeting}");
}

▶ Try it Yourself

Note

first + &second looks odd at first — the + only accepts a &str on the right side, and first gets moved in the process (you can’t use it afterward). format! avoids both quirks, so most Rust code prefers it when combining more than one or two pieces.

Useful string methods

A handful you’ll use constantly:

fn main() {
    let text = "  Hello, Rust!  ";

    println!("{}", text.trim());               // "Hello, Rust!" (no padding)
    println!("{}", text.to_uppercase());        // "  HELLO, RUST!  "
    println!("{}", text.to_lowercase());        // "  hello, rust!  "
    println!("{}", text.contains("Rust"));       // true
    println!("{}", text.trim().len());           // 12 (length in bytes)
    println!("{}", text.trim().replace("Rust", "World")); // "Hello, World!"
}

▶ Try it Yourself

Looping over a string

To go character by character, use .chars():

fn main() {
    for c in "abc".chars() {
        println!("{c}");
    }
}

▶ Try it Yourself

Caution

Rust strings are UTF-8, which means characters can take up more than one byte. That’s why you can’t index a string like text[0] the way you might in other languages — .chars() is the safe way to work through one.

Recap

• &str is borrowed, fixed text; String is owned and can grow.
• Grow a String with .push_str() (for text) or .push() (for a single character).
• Prefer format! over + when combining strings — it’s clearer and doesn’t move anything.
• Common methods: .trim(), .to_uppercase(), .contains(), .replace(), .chars().

Quick check

Quick check

1. Which string type is owned and can grow at runtime?

&strStringBoth grow equally

2. Why does this page prefer format! over + when combining more than one or two strings?

+ doesn't compile with more than two stringsformat! is faster at runtime+ moves the left-hand string and only accepts a &str on the right, which gets awkward

3. Why can't you index a Rust string like text[0]?

Because strings are UTF-8 and characters can span multiple bytesBecause strings are immutableBecause indexing was removed in the latest Rust version

4. Which method adds a single character to a growing String, like greeting.push('!')?

.push_str().push().append()

Score: 0 / 4

Read more

• Storing UTF-8 Encoded Text with Strings — The Rust Book