# Variables
Nushell values can be assigned to named variables using the `let`, `const`, or `mut` keywords.
After creating a variable, we can refer to it using `$` followed by its name.
## Types of Variables
### Immutable Variables
An immutable variable cannot change its value after declaration. They are declared using the `let` keyword,
```nu
let val = 42
$val
# => 42
$val = 100
# => Error: nu::shell::assignment_requires_mutable_variable
# =>
# => × Assignment to an immutable variable.
# => ╭─[entry #10:1:1]
# => 1 │ $val = 100
# => · ──┬─
# => · ╰── needs to be a mutable variable
# => ╰────
```
However, immutable variables can be 'shadowed'. Shadowing means that they are redeclared and their initial value cannot be used anymore within the same scope.
```nu
let val = 42 # declare a variable
do { let val = 101; $val } # in an inner scope, shadow the variable
# => 101
$val # in the outer scope the variable remains unchanged
# => 42
let val = $val + 1 # now, in the outer scope, shadow the original variable
$val # in the outer scope, the variable is now shadowed, and
# => 43 # its original value is no longer available.
```
### Mutable Variables
A mutable variable is allowed to change its value by assignment. These are declared using the `mut` keyword.
```nu
mut val = 42
$val += 27
$val
# => 69
```
There are a couple of assignment operators used with mutable variables
| Operator | Description |
| -------- | -------------------------------------------------------------------------- |
| `=` | Assigns a new value to the variable |
| `+=` | Adds a value to the variable and makes the sum its new value |
| `-=` | Subtracts a value from the variable and makes the difference its new value |
| `*=` | Multiplies the variable by a value and makes the product its new value |
| `/=` | Divides the variable by a value and makes the quotient its new value |
| `++=` | Appends a list or a value to a variable |
::: tip Note
1. `+=`, `-=`, `*=` and `/=` are only valid in the contexts where their root operations are expected to work. For example, `+=` uses addition, so it can not be used for contexts where addition would normally fail
2. `++=` requires that either the variable **or** the argument is a list.
:::
#### More on Mutability
Closures and nested `def`s cannot capture mutable variables from their environment. For example
```nu
# naive method to count number of elements in a list
mut x = 0
[1 2 3] | each { $x += 1 } # error: $x is captured in a closure
```
To use mutable variables for such behaviour, you are encouraged to use the loops
### Constant Variables
A constant variable is an immutable variable that can be fully evaluated at parse-time. These are useful with commands that need to know the value of an argument at parse time, like [`source`](/commands/docs/source.md), [`use`](/commands/docs/use.md) and [`plugin use`](/commands/docs/plugin_use.md). See [how nushell code gets run](how_nushell_code_gets_run.md) for a deeper explanation. They are declared using the `const` keyword
```nu
const script_file = 'path/to/script.nu'
source $script_file
```
## Choosing between mutable and immutable variables
Try to use immutable variables for most use-cases.
You might wonder why Nushell uses immutable variables by default. For the first few years of Nushell's development, mutable variables were not a language feature. Early on in Nushell's development, we decided to see how long we could go using a more data-focused, functional style in the language. This experiment showed its value when Nushell introduced parallelism. By switching from [`each`](/commands/docs/each.md) to [`par-each`](/commands/docs/par-each.md) in any Nushell script, you're able to run the corresponding block of code in parallel over the input. This is possible because Nushell's design leans heavily on immutability, composition, and pipelining.