String and &str in Rust

Rust, known for its emphasis on memory safety without sacrificing performance, has two main string types: String and &str. These types serve different purposes and understanding their differences is very important for writing efficient and safe Rust code.

String

The String type represents an owned, growable, and mutable UTF-8 encoded string. In other words, a String is a heap-allocated string, and you have full control over its contents.

Here's an example demonstrating the creation and manipulation of a String:

fn main() {
    // Creating an empty String
    let mut my_string = String::new();

    // Appending a string slice to the String
    my_string.push_str("Hello, ");

    // Appending another String
    let other_string = String::from("world!");
    my_string.push_str(&other_string);

    // Printing the result
    println!("{}", my_string);  // Output: Hello, world!
}

In this example, String::new() creates an empty String, and push_str is used to append string slices or other String instances.

&str

On the other hand, &str is a string slice that is a view into a string. It's a reference to some UTF-8 encoded data, usually a portion of a String or a string literal.

Let's explore the usage of &str:

fn print_greeting(greeting: &str) {
    println!("{}", greeting);
}

fn main() {
    // Using a string literal
    let hello = "Hello, world!";
    print_greeting(&hello);

    // Using a portion of a String
    let my_string = String::from("Hola, mundo!");
    let hola: &str = &my_string[0..4];
    print_greeting(hola);
}

In this example, print_greeting is a function that takes a &str as an argument. You can pass both string literals and slices of String instances to this function.

Key Differences

1. Ownership and Mutability:

   • String owns its data and is mutable.
   • &str is an immutable reference to a slice of data owned by another variable.

2. Allocation:

   • String allocates memory on the heap to store its data.
   • &str does not own the data; it is a reference to existing data.

3. Usage:

   • Use String when you need ownership and dynamic string manipulation.
   • Use &str when you want to reference existing data or pass slices without taking ownership.

Conclusion

Understanding the distinction between String and &str is crucial for writing efficient, safe, and expressive Rust code. Whether you're dealing with owned, mutable strings or referencing existing data, Rust's type system ensures memory safety without sacrificing performance.