# Variables

* Define variables using `let` statement.
* Variables need initialization. By default variables are immutable unless explicitly declared using `mut`.
* We can declare a new variable with the same name as a previous variable, this is called shadowing.
* Constants are values that are bound to a name and are not allowed to change.
* Constants are always immutable.
* The type of the value ***MUST*** be annotated.
* Reference: [Variables and Mutability](https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html)

## variables1.rs

```rust
fn main() {
    // Adding let
    let x = 5;

    println!("x has the value {x}");
}
```

* `let` statement:

  > A let statement introduces a new set of variables, given by a pattern. The pattern is followed optionally by a type annotation and then either ends, or is followed by an initializer expression plus an optional else block.

  Reference: <https://doc.rust-lang.org/reference/statements.html#let-statements>.
* In this exercise we only need to add `let` without needing to include any type explicitly, the compiler will infer the type.

## variables2.rs

```rust
fn main() {
    // Initialize the variable x to any integer
    let x = 5;

    if x == 10 {
        println!("x is ten!");
    } else {
        println!("x is not ten!");
    }
}
```

* Variables need initialization.
* But you don't need to initialize it on the same line, you can do something like this too:

  ```rust
  let x;
  x = 5;
  ```

## variables3.rs

```rust
fn main() {
    // Initialize the variable x to any integer
    let x: i32 = 10;

    println!("Number {x}");
}
```

* Same as previous exercise, we just need to initialize the variable `x`.

## variables4.rs

```rust
fn main() {
    // Add mutable
    let mut x = 3;
    println!("Number {x}");

    x = 5; // Don't change this line
    println!("Number {x}");
}
```

* By default variables are immutable, so we need to explicitly declare mutability by adding `mut`.
* Reference: <https://doc.rust-lang.org/reference/variables.html>.

## variables5.rs

```rust
fn main() {
    let number = "T-H-R-E-E"; // Don't change this line
    println!("Spell a number: {}", number);

    // Redeclare the number variable below
    let number = 3;
    println!("Number plus two is: {}", number + 2);
}
```

* We can declare a new variable with the same name as a previous variable
* In Rust this is called **shadowing**.
* You can read more about this topic here: <https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html#shadowing>.

## variables6.rs

```rust
// constant need type
const NUMBER: i32 = 3;

fn main() {
    println!("Number: {NUMBER}");
}
```

* Constants are values that are bound to a name and are not allowed to change.
* Constants are always immutable.
* The type of the value ***MUST*** be annotated, so adding `i32` will fix the code.
* Reference: <https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html#constants>