What is a String and a &str in Rust? How are they different?

In Rust, both ‘String‘ and ‘&str‘ are used for handling string data but they are fundamentally different types.

‘String‘ is an owned, growable heap-allocated string type. This means that when we create a ‘String‘, it takes ownership of the memory that holds the string data and is responsible for deallocating it when the string is no longer used.

Here is an example of creating a new ‘String‘:

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

‘&str‘, on the other hand, is a string slice type. It is a borrowed type that borrows a portion of a string. It does not own the string data and cannot modify it. ‘&str‘ is used extensively in Rust because it is a more efficient way of referencing a string when we dont need to modify the string.

Here is an example of creating a ‘&str‘:

    let s = "hello";

The main difference between ‘String‘ and ‘&str‘ is that ‘String‘ is a growable type and owns its data, while ‘&str‘ is a fixed-size type that borrows its data.

Here is an example of converting a ‘String‘ to a ‘&str‘:

    let s1 = String::from("hello");
    let s2: &str = &s1; // s2 borrows s1

In the above example, we create ‘s1‘ as a ‘String‘ and then borrow it to create ‘s2‘ as an ‘&str‘.

It is important to note that ‘&str‘ can reference either a string literal or a ‘String‘ type. Here is an example:

    let s1 = String::from("hello");
    let s2: &str = &s1[0..3]; // s2 is an &str referencing the first 3 bytes of s1
    let s3: &str = "world"; // s3 is an &str referencing a string literal

In conclusion, both ‘String‘ and ‘&str‘ are essential string types in Rust, but they have different ownership and mutability properties. Understanding the differences between them is important for writing efficient and safe Rust code.