PowerShell Variables Tutorials

As a PowerShell developer, you should know how to use variables. Variables in PowerShell are used to store values that can be easily referenced and manipulated throughout your scripts. You will learn everything about PowerShell variables and various PowerShell variable tutorials here.

What is a Variable in PowerShell?

A variable is a storage location paired with a symbolic name (an identifier) that contains some known or unknown quantity of information referred to as a value. In PowerShell, variables store data that can be used and manipulated throughout a script.

Create and Use Variables in PowerShell

In PowerShell, variable names begin with a dollar sign ($). Variable names are not case-sensitive, so $Variable and $variable are considered the same. Here’s a basic example:

$greeting = "Hello, World!"
Write-Output $greeting

In this example, the variable $greeting is assigned the string value "Hello, World!". The Write-Output cmdlet is then used to print the value of $greeting.

Types of Variables in PowerShell

PowerShell variables can store different data types, including strings, integers, arrays, and even objects. Here are some examples of different types of variables:

String Variables

Here is an example of a string variable in PowerShell.

$name = "John Doe"
Write-Output $name

Integer Variables

Here is an example of an integer variable in PowerShell.

$age = 30
Write-Output $age

Array Variables

Here is an example of an array variable in PowerShell.

$colors = @("Red", "Green", "Blue")
Write-Output $colors

Object Variables

Here is an example of an object variable in PowerShell.

$person = New-Object PSObject -Property @{
    FirstName = "John"
    LastName  = "Doe"
    Age       = 30
}
Write-Output $person

Check out PowerShell Variable Naming Conventions

PowerShell Variable Scopes

Variables in PowerShell have different scopes that determine their visibility and lifetime. The main scopes in PowerShell are:

Global: Variables are available throughout the entire PowerShell session.
Local: Variables are available only within the current script or function.
Script: Variables are available within the current script.
Private: Variables are available only within the current scope.

Here’s an example to explain PowerShell variable scopes:

$Global:globalVar = "I am global"
$Script:scriptVar = "I am script-level"
$Local:localVar = "I am local"
$Private:privateVar = "I am private"

function Test-Scopes {
    Write-Output $globalVar
    Write-Output $scriptVar
    Write-Output $localVar
    Write-Output $privateVar
}

Test-Scopes

I executed the above PowerShell script, and you can see the output in the screenshot below:

Special Variables in PowerShell

PowerShell also includes several special variables that have specific purposes. Some of the most commonly used special variables include:

$_: Represents the current object in the pipeline.
$?: Indicates the success or failure of the last operation.
$null: Represents a null value.
$PSVersionTable: Contains details about the PowerShell version.

Here’s an example using the $_ variable:

Get-Process | Where-Object { $_.CPU -gt 100 }

In this example, $_ represents each process object passed through the pipeline, and the Where-Object cmdlet filters processes where the CPU usage is greater than 100.

Best Practices for Using Variables in PowerShell

Here are some best practices to follow when using variables in PowerShell:

Use Meaningful Names: Choose variable names that clearly describe their purpose.
Avoid Global Variables: Minimize the use of global variables to reduce the risk of conflicts and unintended side effects.
Initialize Variables: Always initialize variables before using them to avoid unexpected behavior.
Use Consistent Naming Conventions: Follow a consistent naming convention for variables to improve code readability.

PowerShell Variable Naming Conventions

Here are the naming conventions for PowerShell variables.

Alphanumeric and Underscore: Variable names should use only letters, numbers, and underscores. Special characters and spaces are not allowed.
- Example: $userName, $file_path, $count123
Descriptive and Concise: Choose variable names that clearly describe their purpose but are not overly long. This helps others (and yourself) understand the code more easily.
- Example: Instead of $x, use $totalSales if the variable holds the total sales amount.
PascalCase: This naming convention capitalizes the first letter of each word without spaces or underscores. It is often used for parameter names and sometimes for variables.
- Example: $TotalSalesAmount, $UserName, $FilePath
camelCase: In camelCase, the first letter of the first word is lowercase, and the first letter of each subsequent word is uppercase. This is commonly used for local variables.
- Example: $totalSalesAmount, $userName, $filePath
Dollar Sign Prefix: All PowerShell variable names must start with a dollar sign ($). This is a syntax requirement in PowerShell.
- Example: $variableName, $userAge, $isComplete
Consistency: Use the same naming convention throughout your script to make it easier to read and maintain. Consistency helps avoid confusion and potential errors.
- Example: If you start using camelCase for variables, stick with it for all variables in the script:

$userName = "JohnDoe"
$userAge = 30
$isComplete = $false