PowerShell Operators [Complete Guide]

The most commonly used operators are the assignment operators. These operators are used to assign, manipulate, or append values to variables.

For example, we can assign the value 10 to the variable $count and add 5 to it, making the total 15:

$count = 10
$count += 5
Write-Output $count  # Outputs 15

The basic comparison operators in PowerShell are:

Instead, it will compare the scalar value with each element in the array. If the scalar value exists in the array, then it will return the array element instead of True.

$a = 0,1,2,3
$a -eq 0 # Returns 0
0 -eq $a # Returns False

We also have comparison operators that we can use to find or even replace patterns in strings. The -match and -replace operators use regex for the comparison whereas the -like operator uses a wildcard.

The only difference between the two is the place of the value and collection. Which one you should use really depends on the context.

The last comparison operators that we can use in PowerShell are the -is operators. This one isn’t used a lot but allows you to check if an object is of the specified type or not.

Logical Operators are used to connect conditional statements in PowerShell to a single statement.

For example, we can use the -and operator to check if a value is less than 10 and greater than 2 with the command below:

$val = 5
if ($val -lt 10 -and $val -gt 2)  {
    Write-Output "Both conditions are met"
}

You can use the redirection operators to send the output of a command to a text file. The different options not only allow you to send or append the normal (standard) output to a file. It’s also possible to redirect only the error stream or warning stream. Which is great when you want to create an error log for your script.

For example, to write only the errors of a command to a file we can use the redirect stream operator:

# Write only the error to the file:
Get-ProcessCpu -name "explorer2" 2> C:\temp\process-error-log.txt

The split and join operators are used to split or join strings.

We have seen the type operator -is also in the comparison operator section. The operator is used to check if a variable is of a specific type. But besides the -is operator, we can also use the -as operator to convert a variable into a specific type.

The -as operator is particularly handy when you need to convert a string into an integer for example

$number = "123"
if ($number -is [string]) {
    $converted = $number -as [int]
    Write-Output "Converted: $converted"
}

Unary operators are used quite a lot, especially in loops, to either keep track of the index or for counting. Fun fact, the ++ operator is probably the most used, but most don’t know that it’s called a Unary operator.

These operators don’t really fit into the other groups, because each has there own special use case

The grouping operators, better known as parentheses, are used to ensure that expressions or cmdlets are executed in a specific order. In the example below, we want the get the item path first, and then check if the length is greater than 100.

$path = "C:\MyScripts\script.ps1"
if ((Get-Item $path).Length -gt 100) {
 Write-Host "Long path"
}

The ternary operator was released in PowerShell 7. It simplifies the if-else statements, making them easier to read. I do recommend only using the ternary operator for short if-else statements that fit on a single line.

In the example below we check if the variable $x is greater than 10, if that is the case, we set the status to high, otherwise to low:

# Define a variable
$x = 15

# Use the ternary operator to assign a value based on a condition
$status = ($x -gt 10) ? 'High' : 'Low'

# Output the result
Write-Output "The status is $status"

If the value on the left side of the operator equals null, then the value on the right side (which can also be variable) is returned. You can also combine multiple null-coalescing operators to find the first non-null value.

One of the nice things about the Null-coalescing Operators is that it allows you to, for example, only access a property of an object if that object is not null:

# Define an object with a property
$person = [PSCustomObject]@{ Name = "Alice" }

# Access the 'Name' property only if $person is not null
$name = $person?.Name