Learn how variables work in PowerShell, including types and assignments. Discover the many operators available to work with variables in the terminal and in CmdLets.  

Variables and Operators

Comparison operators are used to compare values, test conditions, or filter elements of a collection, such as an array. They return a Boolean value, `True` or `False`, as a result.

#### Equality Operators
Some of the comparison operators in PowerShell are called equality operators. They are binary operators that compare two integer or string values that return `True` if the operator condition is met; otherwise, `False`.

Operator | Description
--- | ---
`-eq` | Checks if the two operand values are an exact match
`-ne` | Checks if the two operand values are NOT an exact match
`-gt` | Checks if the value of the left operand is greater than the value of the right operand
`-lt` | Checks if the value of the left operand is less than the value of the right operand
`-ge` | Checks if the value of the left operand is greater OR equal to the value of the right operand
`-le` | Checks if the value of the left operand is less OR equal to the value of the right operand

Let's take a look at a few examples.

##### `-eq` and `-ne`
In the example below, `-eq` returns `True` because `$my_num` matches the value `5`. When we use the `ne` operator on the same operands, it returns `False` since it only returns `True` when the two values are NOT a match.
```PowerShell
PS > $my_num = 5
PS > $my_num -eq 5
True

PS > $my_num -ne 5
False
```

The `-eq` and `-ne` also work on strings, as shown below.
```PowerShell
PS > "tomato" -ne "vegetable"
True
```

##### `-gt` and `-lt`
The first expression in the example below returns `True` since `7` is greater than `2`. `42` is not less than `42`, so the second expression returns `False`.
```PowerShell
PS > 7 -gt 2
True

PS > 42 -lt 42
False
```

##### `-ge` and `-le`
In the example below, `3` is not greater than or equal to `6`, so `False` is returned, and `42` is less than or equal to `42`, so `True` is returned.
```PowerShell
PS > 3 -ge 6
False

PS > 42 -le 42
True
```

Equality Comparison Operators

Just like in mathematics, the order in which operators are evaluated matters in programming. Operator precedence in PowerShell is as follows:
- `( )`
- `++` `--`
- `!` `-not`
- `*` `/` `%`
- `+` `-`
- `-is` `-isnot` `-as`
- `-eq` `-ne` `-gt` `-ge` `-lt` `-le`
- `-contains` `-notContains`
- `-and` `-or` `-xor`
- `=` `+=` `-=` `*=` `/=` `%=`

Precedence order is the order in which PowerShell evaluates the operators if multiple operators are used in the same expression. Parentheses `( )` take the highest priority, and the assignment operators have the least priority. Operators on the same level are evaluated from left to right. Consider the example below.

```PowerShell
PS > 5 - 1 * 5
0
```
The multiplication operator `*` has higher precedence than the subtraction operator `-`. Thus, in the example above, the expression `1 * 5` is evaluated first, resulting in `5 - 5`, which equals `0`.

We can use parentheses to override the precedence order and force PowerShell to evaluate a part of an expression first.
```PowerShell
PS > (5 - 1) * 5
20
```


Operator Precedence

*Environment Variables* store information related to the current environment, like the Operating System and user sessions like our current terminal. They are global variables, meaning we can access them across commands and programs. The operating system usually creates them, but we can also use them to configure our production environment. 

#### List Environment Variables
In PowerShell, environment variables are stored as strings. We can use the `Get-ChildItem` cmdlet on the `Env:` drive to get a complete list of all existing environment variables.
```PowerShell
PS > Get-ChildItem Env:
Name                           Value
----                           -----
BROWSERSLIST_IGNORE_OLD_DATA   1
EIN_IMAGE                      ubuntu
…
```

To get the specific value of an environment variable, we can use either of the following commands:
```
(Get-ChildItem Env:EIN_IMAGE).Value
> ubuntu
$Env:EIN_IMAGE
> ubuntu
```
Two popular environment variables in PowerShell are `HOME` and `PATH`. The `HOME` environment variable specifies the current user's home directory, whereas `PATH` includes all the directories where applications look for executables.

#### Create an Environment Variable
The syntax to create environment variables in PowerShell is as follows:
```PowerShell
$Env:EXAMPLE_ENV_VAR = "custom value"
```
By convention, environment variable names are usually capitalized.

The benefits of environment variables are that they are accessible across the terminal session and scripts. This allows our session to operate in one environment where all data is consistent across processes.

Environment Variables

Let's start by discussing how variables work. In computer programming, *variables* are used to store a piece of data. In PowerShell, variables can store the results of commands and expressions like values, names, paths, and settings.

#### Create a Variable
To create a variable, we must assign it a value. Variables in PowerShell are referenced using a dollar sign `$` followed by a variable name. After a variable reference, we use an equal sign `=` followed by the value we'd like to assign to that variable. 
```PowerShell
$my_string_variable = "Hello, World!"
```
In the example above, we are initializing a variable called `my_string_variable` to a string value of `Hello, World!`.

Variables names consist of alphanumeric characters. They are NOT case-sensitive and can include spaces and special characters when enclosed in curly braces, `{}`. However, following the convention of using only alphanumeric characters and the underscore `_` character is recommended because variables with special characters in their name are difficult to use.

#### Use a Variable
```PowerShell
PS > $my_string_variable
Hello, World!
```
Variable reference allows us to use or manipulate variables. As shown above, referencing the variable `my_string_variable` we defined earlier in the PowerShell terminal prints the value we assigned to it.

#### User Input
Now that we can hold data using variables, we can look at a useful command that enables user input through the terminal.
```PowerShell
PS > $my_input = Read-Host -Prompt "Enter a number"
```
The above example will output the `-Prompt` string and then wait for the user to input a value and hit <kbd>Enter</kbd>. The value will then be stored in `$my_input` for use later.

These a just a few ways we can use variables to collect, process, and output data within our terminal and scripts.

Variables

*Operators* are used to perform specific operations on data, often stored in a variable. PowerShell offers multiple types of operators to manipulate data, including:
- Arithmetic Operators
- Assignment Operators
- Unary Operators
- Comparison Operators
- Logical Operators

#### Arithmetic Operators
First, let's discuss arithmetic operators used to calculate numeric values. Arithmetic operators include:
- `+` (Addition): adds numbers and concatenates strings
- `-` (Subtraction): subtracts or negates numbers
- `*` (Multiplication): multiplies numbers or copies strings a specified number of times
- `/` (Division): divides numbers
- `%` (Modulus): returns the remainder of a division operation

```PowerShell
PS > 5 + 5
10

PS > 25 % 3  # 25/3 = 8 remainder 1
1
```
Arithmetic operators are binary, meaning they require two operands to calculate the result. As we can see in the examples above, the syntax for arithmetic operators is `<Operand_1> <Arithmetic-Operator> <Operand_2>`. Operators are best utilized when used with variables, as shown below.
```PowerShell
PS > $number = 25
PS > $number / 5
5

PS > $number = $number * 3
PS > $number
75
```

#### Arithmetic Operators on Strings
PowerShell allows us to manipulate strings using the addition `+` and multiplication `*` operators. The `+` operator concatenates strings, whereas the `*` operator copies the string a specified number of times.
```PowerShell
PS > $best_learning_platform = "Code" + "cademy"
PS > $punctuation = "!" * 3
PS > $best_learning_platform + $punctuation
Codecademy!!!
```
You can see two strings are joined to create the string `"codecademy"` and three exclamation points are made into a string by multiplying `"!"` by `3`.

Arithmetic Operators

In this exercise, we will discuss how variable types are handled in PowerShell and a few advanced ways to interact with variables, including enforcing types, creating multiple variables, and a few variable-related cmdlets.

#### Variable Types
The following are some common types of variables:
- `Int`: integers like `2`, `-5`, `99`
- `String`: zero or more characters enclosed in double quotes like `"Codecademy!"`, `"3X4mP|3"`
- `Boolean`: two possible values: `$True` and `$False`
- `Array`: a collection of items like `25, "red", $False, 16.30`

PowerShell assigns a type to the variable depending on the value we assign to it. This is called dynamic typing. The default type of any uninitialized variable is `$null`. 

We can append `.GetType().Name` to the variable reference to determine a variable's data type.
```PowerShell
PS > $my_string_variable = "Hello, World!"
PS > $my_string_variable.GetType().Name
String
```
In the example above, we are accessing the `Name` property of the `GetType()` method of a variable we initialized.
- The `GetType()` method returns the name and base type property for a variable
- Accessing the `Name` property only returns the data type we desire
- The variable's data type is `String`

#### Constrained Variables
If we wish to enforce a certain type on a variable, we can create a *constrained variable* via casting.
```PowerShell
PS > [Int]$age = 25
PS > $age
25

PS > [Int]$age = "twenty five"
Cannot convert value "age" to type "System.Int32". Error: "Input string was not in a correct format."
```
When initializing a variable, we specify the type in brackets before referencing the variable. Attempting to assign a value of another type results in an error if PowerShell cannot convert it.

#### Create Multiple Variables
PowerShell allows us to create multiple variables using one statement. To initialize multiple variables with the same value,
```PowerShell
$i = $j = $k = 0
```

To assign multiple values to multiple variables,
```PowerShell
$number, $color, $bool = 25, "red", $false
```

We will next discuss a specific type of variable called an environment variable.

Variable Types and Advanced Usage

Welcome to the "Variables and Operators" lesson of your PowerShell journey. Regardless of our use case, one inevitable aspect of programming is storing and manipulating data to serve our needs. Data comes in various forms, such as:
- Numbers (integers): `1`, `-99`, `42`
- Text (strings): `"Hello!"`, `"BF1942"`
- Booleans: `True`, `False`
- and more!

We will first cover various ways to create and use variables to store multiple types of data. We will then explore operators enabling us to perform arithmetic operations and compare the values of two or more pieces of data. 

This interaction and manipulation of data, coupled with variables, will build the foundation required to write PowerShell scripts.

Text image with the title, Variables and Operators, and a quote, Regardless of our use case, one inevitable aspect of programming is storing and manipulating data to serve our needs.

Introduction

In this exercise, we will take a look at logical operators.

Logical operators allow us to combine multiple `True`/`False` expressions and statements into complex conditionals. Using the operators `-and`, `-or`, `-xor`, `-not`, `!`,  we can test multiple conditions with the equality comparison operators we discussed in the previous exercise.
##### Truth Table

A simple way to show the output of logical operators is through a truth table.

x | y | x -and y | x -or y | x -xor y | -not x
--- | --- | --- | --- | --- | ---
T | T | T | T | F | F
T | F | F | T | T | F
F | T | F | T | T | T
F | F | F | F | F | T

As shown in the first two columns, imagine `x` and `y` are variables that hold the boolean values. The rest of the columns show the output of the corresponding logical operator given the values for `x` and `y` for that row. Let's explore a few PowerShell examples.

##### `-and`
The `and` logical operator is a binary operator that returns `True` if both statements are `True`.
```PowerShell
PS > -5 -lt 7 -and "hello" -eq "hello"
True

PS > -5 -lt 7 -and "hello" -eq "world"
False
```

##### `-or`
The binary `or` logical operator returns `True` if either statement returns `True`.
```PowerShell
PS > 42 -le 13 -or 5 -ge 5
True

PS > 42 -le 13 -or 5 -gt 5
False
```

##### `-xor`
This binary operator returns `True`  when only ONE statement is `True`.
```PowerShell
PS > 25 -gt 2 -xor "hello" -eq "world"
True

PS > 25 -gt 2 -xor "code" -eq "code"
False
```

##### `-not` and `!`
Both the `-not` and `!` operators negate the statement that follows. They are unary operators.
```PowerShell
PS > -not (2 -gt 5)
True

PS > !(17 -le 99)
False
```

Logical Operators

In this exercise, we will discuss the assignment and unary operators. 

#### Assignment Operators
We can use assignment operators to assign, change, or append values to variables. The general syntax of the assignment operators is as follows: `<Variable> <Assignment-Operator> <Value>`.

We are already familiar with one of the assignment operators, `=`. It is used to assign a value to a variable. Other assignment operators include `+=`, `-=`, `*=`, `/=`, and `%=`. These operators are called *compound* assignment operators. 

Notice that an arithmetic operator precedes the `=`. This means compound assignment operators perform operations on the values before the assignment. Consider the following example:
```PowerShell
PS > $number = 75
PS > $number_1 = $number / 3
PS > $number_1
25
PS > $number_2 = $number
PS > $number_2 /= 3
PS > $number_2
25
```

We can use the `/=` compound assignment operator as a shorthand for dividing a variable and saving the result to the same variable. As shown above, the statements ` $number_1 = $number / 3` and `$number_2 /= 3` behave similarly.

#### Assignment Operators on Environment Variables
Recall that environment variables are of type `String` and that the `+` arithmetic operator can concatenate strings. We can append the  `+=` compound assignment operator to an existing environment variable.
```PowerShell
PS > $Env:EXAMPLE_ENV_VAR = "custom value"
PS > $Env:EXAMPLE_ENV_VAR += "; another value"
PS > $Env:EXAMPLE_ENV_VAR
custom value; another value
```

Note: Environment variables that have multiple values are separated by a semicolon `;` on Windows. For example, the `PATH` environment variable specifies the directories in which executable programs are located. Utilizing `;` with the `+=` assignment operator, we can add new directories to `PATH`.

#### Unary Operators
Unary operators operate on a single variable operand. `++` and `--` are the increment and decrement operators and increase or decrease the value of a variable by 1, respectively.
```PowerShell
PS > $i = 0
PS > $i++
PS > $i
1

PS > $i--
PS > $i
0
```
Unary operators are an easily readable way to increase or decrease a variable value by `1`.

Assignment and Unary Operators

Good job on making it to the end of Variables and Operators! In this lesson, we learned the following:
- How to create variables in a variety of ways
- Variable types and constrained variables
- Listing and creating environment variables
- Manipulate variables and data with operators
- Using arithmetic operators to perform mathematical operations
- Using assignment and unary operators to change data 
- Using equality and type comparison operators to compare two pieces of data
- Using logical operators that enable us to create complex comparison statements
- Order of operations