String vs. &str: Types and Conversions

1. The Two String Types: An Overview

At a high level, the difference can be summarized like this:

• String: An owned, mutable, growable string. It's stored on the heap, which means its size can change at runtime. You use String when you need to create or modify string data, like building a player's name from user input.
• &str (pronounced "string slice"): A borrowed, immutable "view" or "slice" into string data. It's a reference to a sequence of characters that is stored somewhere else—either in the program's binary, on the heap inside a String, or on the stack. You use &str when you just need to read string data without taking ownership of it.

Think of it this way: a String is like owning the original, editable document file on your computer. A &str is like a read-only link to that document that you can share with others.

This diagram gives a great visual breakdown of how these types are represented in memory.

The most common place you'll see a &str is with string literals, the hardcoded strings you type directly in your code.

// This is a string literal. Its type is &'static str.
// The text "Hello, world!" is stored directly in our compiled program's binary.
let my_slice = "Hello, world!";

2. Understanding Memory and "Views"

To really grasp the difference, it's helpful to think about what's happening in memory. The following video provides a clear, concise explanation.

As the video explained, using &str is highly efficient because it avoids allocating new memory when you just need to pass string data to a function. This is a very common pattern in Rust.

3. Converting Between String and &str

Since you'll be working with both types, you need to know how to convert between them. This is a very common task in Rust programming. The article below gives a straightforward guide with code examples.

Now, let's put this into practice.

From a Slice to an Owned String (&str -> String)

When you have a &str (like a string literal) and you need an owned String that you can modify or give to another part of the program, you create a new String. This process allocates memory on the heap and copies the data.

You can do this in two main ways:

1. Using the .to_string() method.
2. Using the String::from() function.

fn main() {
    // This is a string slice (&str)
    let move_notation_slice = "e2e4";

    // Convert it to an owned String using .to_string()
    let owned_move_1 = move_notation_slice.to_string();

    // Convert it to an owned String using String::from()
    let owned_move_2 = String::from(move_notation_slice);

    // Now these are both of type String, and we can modify them
    println!("Owned string 1: {}", owned_move_1);
    println!("Owned string 2: {}", owned_move_2);
}

From an Owned String to a Slice (String -> &str)

This is the more common and efficient direction. If you have a String but a function only needs to read its contents, you can pass a slice (&str) to it. This is cheap because it doesn't allocate any new memory.

You can get a &str from a String by using the & operator, which creates a reference.

fn main() {
    let player_name = String::from("Magnus");

    // Pass a slice of the String to our function
    print_greeting(&player_name);
    
    // We can still use player_name here because we only 'lent' it to the function
    println!("Welcome, {}!", player_name);
}

// This function takes a string slice.
// It can accept both a &str literal and a reference to a String.
fn print_greeting(name: &str) {
    println!("Hello, {}! It's your turn.", name);
}

Run this code. Notice how print_greeting works with &player_name. Rust automatically converts &String into &str for you in this situation, a feature called deref coercion. This makes writing functions flexible.

Hands-On Activity

Let's apply this to our rust_chess project. We'll simulate getting player names as owned Strings and then passing them to a function that prints a welcome message.

1. Open your src/main.rs file.
2. Delete any previous code from the main function.
3. Define two String variables, player1_name and player2_name, initialized with some names.
4. Write a function welcome_player that accepts one parameter, name, of type &str. This function should print a welcome message, like "Welcome to the game, [name]!".
5. In your main function, call welcome_player for both players. You'll need to pass a reference to each name.
6. Run cargo run to see the output.

Your final code might look something like this:

fn main() {
    let player1_name = String::from("Player 1");
    let player2_name = "Player 2".to_string(); // Just to show both methods work!

    println!("Setting up the game...");

    welcome_player(&player1_name);
    welcome_player(&player2_name);
}

fn welcome_player(name: &str) {
    println!("Welcome to the game, {}!", name);
}

Conclusion

Excellent work! You've just navigated one of the most important distinctions in Rust. Getting comfortable with String and &str will make the rest of your journey much smoother.

Key Takeaways:

• String is an owned, heap-allocated, and growable text buffer. Use it when you need to create or modify string data.
• &str is an immutable, borrowed "view" into string data. It's lightweight and efficient for passing to functions that only need to read the data.
• To convert from &str to String, use .to_string() or String::from(). This allocates new memory.
• To get a &str from a String, simply take a reference with &. This is cheap and does not allocate memory.

You might be wondering why Rust makes this distinction. It's all related to Rust's core feature for memory safety: ownership. The concepts of "owning" data (String) and "borrowing" a view of it (&str) are central to how Rust prevents common bugs like memory leaks or dangling pointers.

In our next lesson, we will dive headfirst into the ownership system. You'll see how it governs not just strings, but all data in a Rust program.