Rust Tutorials: Capturing Variables 🎯

Welcome to our deep dive into Rust's capturing variable concept! Let's get started on this exciting journey.

What are Variables in Rust? 📝

In programming, variables serve as a storage for data. They allow us to name and work with the data in our code. In Rust, variables are used to store different types of data such as numbers, strings, and Boolean values.

Understanding Variables in Rust 💡

Rust has a strong emphasis on type safety, which means that each variable in Rust has a specific type. This helps prevent errors and makes the code more reliable. Let's take a look at some of the basic types of variables in Rust.

Types of Variables in Rust 📝

const - Constant variables that cannot be changed once assigned
let - Variables that can be assigned a value and changed later
mut - Variables declared with the mut keyword, which can be changed multiple times

Working with let Variables 🎯

The most common type of variable in Rust is the let variable. Let's take a look at how to create and use a let variable.

rust

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);
}

In the example above, we have a variable x of type i32 (a common integer type in Rust) and we assign it the value 5. We then print the value of x to the console using the println! macro.

💡 Pro Tip: In Rust, variables are by default immutable, meaning they cannot be changed once assigned. If you want to change the value of a variable, you must declare it as mut instead of let.

Changing Variable Values with mut ✅

To change the value of a variable, you can use the mut keyword.

rust

fn main() {
    let mut x = 5;
    x = 10;
    println!("The value of x is: {}", x);
}

In the example above, we have declared the variable x as mutable, and we can now change its value to 10.

Shadowing Variables 💡

Rust allows you to create a new variable with the same name as an existing one, which is called shadowing. This can be useful when you want to assign a new value to a variable without worrying about its previous value.

rust

fn main() {
    let x = 5;
    let x = 10;
    println!("The value of x is: {}", x);
}

In the example above, we create a new x variable with the same name as the existing one, effectively shadowing the old variable. The new variable now has the value 10.

Quiz 🎯

That's it for our introduction to capturing variables in Rust! In the next lesson, we will dive deeper into Rust's data types and explore how to work with them. Happy coding! 🎯