Introduction to String Data Types

Hello! Welcome to your first lesson on String Data Types in Rust. Strings are an essential part of any programming language because they enable you to store and manipulate text. In this lesson, we'll delve into the fundamental concepts of strings in Rust, covering literals, the String type, references, and string slices. By the end of this lesson, you'll have a solid understanding of how to work with strings efficiently and effectively in Rust.

String literals are the most basic form of strings in Rust. They are immutable and stored directly in the binary file that also holds the code. Here's a simple example:

fn main() {
    let greeting = "Hello, world!";
    println!("{}", greeting); // Prints: Hello, world!
}

String literals are ideal for text that doesn't need to change, as they provide excellent performance and safety.

The String type in Rust is more complex and flexible than string literals. It supports mutability and is allocated in memory when the program runs. To declare a String, use String::from followed by a string in quotes. Here's an example:

fn main() {
    let hello = String::from("Hello");
    println!("{}", hello); // Prints: Hello
}

The String type is useful when you need a growable, mutable text representation.

You might be asking, what is the difference between a String and string literal.

String literals are immutable and stored directly in the program's binary. They have a static lifetime, meaning they are valid for the entire duration of the program. Assigning a variable to a string literal creates an immutable reference with a static lifetime (&'static str). Therefore, string literals are not considered Copy types. Assigning a new variable to a string literal does not transfer ownership or make a copy of the data. Instead, the new variable is just a reference to where the string literal is stored in the code binary.

The String type is allocated in memory when the program runs. When you want to use a String without transfering ownership, use a reference instead by using &.

fn main() {
    // String Literal
    let s1 = "Hello";
    let s2 = s1;
    println!("{}", s1); // Prints: Hello
    println!("{}", s2); // Prints: Hello


    // String type
    let s3 = String::from("Hello");
    let s4 = &s3; // s4 is a reference to s3
    println!("I am a reference to {}", s4); // Prints: I am a reference to Hello
    println!("I still own {}", s3); // Prints: I still own Hello

}

• s1 is a string literal. The type of s1 here is &'static str.

• let s2 = s1; copies the reference of the string literal. Because s1 and s2 are both &'static str, the assignment does not transfer ownership. In other words, both s1 and s2 point to the same string literal "Hello".

• s3 is a String type.

• s4 is a reference to s3. The & symbol creates an immutable reference. The type of s4 is &String.

References are powerful as they allow multiple parts of your code to read the same data without interfering with each other.