PowerShell Operators

Understanding how operators work will lead to more efficient code.

PowerShell is intended to be an interactive command-line, but it’s also a programming language. As we advance into PowerShell knowledge, it’s inevitable for us to learn many of core computer programming concepts. The operator is one of those important programming concepts that you probably have been using but without having comprehensive knowledge about them.

The operator belongs to one or more characters in an expression or command that PowerShell interprets in a specific way. While creating a module or script, we’ll use PowerShell operators and those are categorized into several types. For instance, operators for performing arithmetic, operators for comparing values, operators for manipulating strings, and more.

Get in-depth knowledge of task automation and configuration management with our PowerShell Training

Different Types of PowerShell Operators

1.Arithmetic Operator

Arithmetic operators are used in mathematical expressions as used in algebra. These operators also include the modulus (%) operator to calculate the remainder of the division operation. This means we can use PowerShell just by typing expressions at the PowerShell prompt.  

We can use PowerShell as a simple calculator by just typing expressions at the PowerShell prompt. The arithmetic expressions in PowerShell are evaluated from left to right as per the order of operations unless we use parentheses for grouping (multiplication, division, addition, then subtraction). The spaces between the operators are ignored in PowerShell to make things clearer.

The + and * operators can also be used to work with strings. When you use the * operator, it repeats a string. When you use the + operator, it concatenates strings. 

Assume integer variable A holds 30 and variable B holds 10, then −

2. Assignment Operators

In PowerShell, the assignment operators are used to assign, change, or append the values in a variable. (=) is the most commonly used assignment operator, which is used for assigning a given value to the variable. 

There are some other assignment operators (*=, %=, /=,), which are used for modifying the value of a variable.

Related Article: PowerShell Tutorial 

3. Logical Operators

In PowerShell, the logical operators are used to connect statements or expressions collectively to form a single expression. The expressions which contain the logical operators usually result in the Boolean values $True or $False.

The logical operators connect conditional statements into a single complex conditional. Assume Boolean variables X holds true and variable Y holds false, then −

The PowerShell stops evaluating expressions on either side of a logical operator once it returns a $true result, and this is called short-circuit evaluation.

4. Comparison Operators

The comparison operators are used in PowerShell to compare the values for equality, matching, containment, and replacement. These operators are prefixed with a hyphen (-) such as -eq like the majority of other operators, to verify whether two values are equal.

PowerShell includes the following comparison operators:

4.1. Equality Operator

All the equality operators return a boolean value ($true or $false). The operators return a value of TRUE or matches when input values identical to the specified pattern. The entire pattern must match an entire value.

• -eq: Equal to. Includes an identical value.

Example:

PS> 4 -eq 4 

PS> 4 -eq 3

PS> "xyz" -eq "xyz"

PS> "xyz" -eq "xyz", "def"  

• -ne: Not equal to. Includes a different value.

Example:

PS> "xys" -ne "ghu"

PS> "xys" -ne "xys"

PS> "xys" -ne "xys", "def"

• -gt: Greater-than.

Example:

PS> 8 -gt 6

PS> 7, 8, 9 -gt 8

• -ge: Greater-than or equal to.

Example:

PS> 8 -ge 8

PS> 7, 8, 9 -ge 8

8

9

• -lt: Less-than.

Example:

PS> 8 -lt 6

PS> 7, 8, 9 -lt 8

• -le: Less-than or equal to.

Example:

PS> 6 -le 8

7

4.2. Match operators:

The match operators are “-like”, “-notlike”, “-match”, and “-notmatch”. 

The operators like “-like” and “-notlike” use wildcard characters to find the elements that match or don’t match a specified pattern.

The syntax is:

<string[]> -like <wildcard-expression>
<string[]> -notlike <wildcard-expression>

Whereas “-match” and “-notmatch” operators use regular expressions to find elements that match or do not match a specified pattern . 

The syntax is:

<string[]> -match <regular-expression>
<string[]> -notmatch <regular-expression>?

4.3. Containment Operators:

There are two containment operators in PowerShell such as “-contains” and “-notcontains”, which are similar to equality operators. They always return a boolean value depending on whether the value on the right side of the operator exists in the set of values on the left side of the operator (true or false).

• -contains

This operator tells whether a set of reference values includes a single test value

Syntax: 

<Reference-values> -contains <Test-value>

Returns true only when the test value exactly matches the at least one of the reference values.

Example:

PS> "xyz", "abc" -contains "abc"

PS> "Linux", "Windows" -contains "Drive"

• -notcontains

This operator tells whether a collection of reference values includes a single test value. Also, returns TRUE when the test value is not an exact match for at least one of the reference values.

Syntax:

<Reference-values> -notcontains <Test-value>

Example:

PS> "Linux", "Windows" -notcontains "Drive"

• -in

The -in operator was introduced in PowerShell 3.0. This operator tells whether a test value appears in a collection of reference values. Returns TRUE only when the test value exactly matches at least one of the reference values.

Syntax:

<Test-value> -in <Reference-values>

Example: 

PS> "xyz" -in "dfg", "xyz"

PS> "Drive" -in "Windows", "Linux"

PS> "Drive" -in "Drive", "Windows"

• -notin

The “-notin” operator was introduced in PowerShell 3.0. This operator tells whether a test value appears in a collection of reference values. Returns TRUE when the test value is not an exact match for at least one of the reference values

Syntax:

<Test-value> -notin <Reference-values>

PS> "xyz" -notin "dfg", "xyz"

PS> "abc" -notin "hjk", "oip"

4.4. Replacement operator:

This operator replaces part of the value or all the value with the specified value using regular expressions. It uses two arguments for a regular expression pattern and replacement value, and those are separated by a comma.

Let’s take a look into PowerShell Interview Questions

The syntax of the -replace operator is as follows, the <original> placeholder describes the characters to be replaced, whereas the <substitute> placeholder describes the characters that replaces them:

<input> <operator> <original>, <substitute>

By default, the -replace operator is case-insensitive. We can use  -creplace to make it case sensitive. Use -ireplace, to make it explicitly case-insensitive. 

Example:

PS> "Maddy" -replace "M", "D"

"maddy" -ireplace "M", "D"

"maddy" -creplace "M", "D"

Related Article: PowerShell Interview Questions

5. Type comparison:

To determine whether an object belongs to a specific type, type comparison operators are used in PowerShell. There are two type comparison operators such as “-is” and “-isnot”.

• -is

Syntax:

<object> -is <type reference>

Example:

PS> $a = 5
PS> $b = "5"
PS> $a -is [int]
True
PS> $a -is $b.GetType()
False?

• -isnot

Syntax:

<object> -isnot <type reference>

Example: 

PS> $a = 5
PS> $b = "5"
PS> $a -isnot $b.GetType()
True
PS> $b -isnot [int]
True?

6. The Split and Join Operators

To divide and combine substrings, split and join operators are used. The -split operator is used to split a string into substring, whereas the -join operator is used to concatenate various strings to a single string. Both these operators are widely used in PowerShell scripts for manipulating strings. It allows you to specify one or more delimiter characters for how the PowerShell should split or join strings.

7. Redirection Operator:

Redirection operators are very important to use in PowerShell, as of now it supports output redirection, but might support input redirection in future versions. The redirection operators supported from PowerShell 3.0 are listed below:

Related Article: Explore the list of basic PowerShell commands

8. Unary operators:

To increment or decrement variables or set integers to a positive or negative value, we use unary operators in PowerShell.

For example, to increment the variable $a from 20 to 21, we type $a++.

9. Special Operators:

PowerShell special operators have specific use-cases that don’t fall into any other operator groups. The functioning of these special operators includes changing a value’s data type, running commands or retrieving elements from an array.

Let’s take a look at different special operators used in PowerShell.

• The invocation (&) operator

This operator is used to run a script, command, or script block. The & operator is used to run a program that contains spaces in its path or name.

For instance, for the following command

"D:Program Files (x86)Test AppMyApp.exe"

It just displays a string on screen but doesn’t start the program MyApp.exe. To run MyApp.exe as a program, just place the & operator before the string:

& "D:Program Files (x86)Test AppMyApp.exe"

• Subexpression operator $( )

This is used to evaluate the expression in between the $( and the ) characters. This operator is used to return one or more statements. It returns scalar for a single statement and returns an array for multiple statements. For using an expression within another expression, we use this operator.

Example: To embed the results of a command in a string expression

PS> "Today is $(Get-Date)"

PS> "Folder list: $((dir c: -dir).Name -join ', ')"

•  Array subexpression operator @( )

This operator returns the result of one or more statements as an array. If there is only one item, the array has only one member.

@(Get-CimInstance win32_logicalDisk)

• The static member (::) operator. 

For accessing a static member of a .NET class, we use the static member operator

 A class is a type of object, and a static member is a property or method of a class. For example, the expression

[DateTime]::Now

• The range operator (..)

Returns an array of integers represented by the upper and lower bounds of integers on either side of the two consecutive dots.

For example, expression 3..6 outputs a four-element array (3,4,5,6) and expression 6..4 outputs a three-element array (6,5,4).

• The comma (,) operator. 

The comma operator (,) will create an array as a binary operator and creates an array with one member as a unary operator. If you place the comma operator before a single value, you can create a one-element array. 

For example, the expression

$items = ,"B"

Assigns a one-element array to the variable $items. 

You can also place the comma operator between items in a list to create a multiple-element array. For example, the expression

$items = "X","Y","Z"

• Format operator -f

Formats a string based on .NET string formatting rules. On the left side of the operator enter the format string and on the right side of the operator enter the objects to be formatted.

For example,

"{0} {1,-10} {2:N}" -f 1,"hello",[math]::pi

Output: 

1 hello      3.14

• The dot sourcing (.) operator

This operator is used to run a script in the current scope and is followed by space. The PowerShell creates a new scope for the script you run that functions and variables, the script creates are discarded when the script terminates. 

While running a script, if you don’t want PowerShell to create a new scope, then prefix the script with the dot sourcing operator.

For example, If we have a list of useful functions in the script file Sample.ps1. Use the dot sourcing operator to load the scripts:

.  Sample.ps1 

The functions defined in Sample.ps1 will now be available after the script terminates.

• Null-coalescing assignment operator ??=

If the left-hand operand evaluates to null, then the operator assigns the value of its right-hand operand to its left-hand operand only. If the left-hand operand evaluates to non-null, then the operator doesn't evaluate its right-hand operand.

For example,

$x = $null
$x ??= 200
$x?

Output: 

200

In the following example, the right-hand operand won't be evaluated.

[string] $todaysDate = '27/06/2020'
$todaysDate ??= (Get-Date).ToShortDateString()?

Output:

27/06/2020

• Null-coalescing operator ??

Thi operator returns the value of its left-hand operand if it isn't null.  Otherwise, evaluates the right-hand operand and returns its result. If the left-hand operand evaluates to non-full, this operator doesn’t evaluate its right-hand operand.

For example:

$x = $null
$x ?? 200?

Output: 200

In the following example, the right-hand operand won't be evaluated.

[string] $todaysDate = '27/06/2020'
$todaysDate ?? (Get-Date).ToShortDateString()?

Output: 27/06/2020

Conclusion:

In this blog, we have covered a variety of operators in PowerShell. It’s always helpful for you to know in advance what type of operator you are working in PowerShell to improve the efficiency of your code. 

Also, if you are looking for a structured learning approach towards PowerShell, then enroll in our PowerShell Course that kick starts your PowerShell career.

PS> 7, 8, 9 -le 8