How To Examine Strings In PowerShell (2023)

On this article, we are going to discover the varied comparability parameters obtainable in PowerShell and the way they can be utilized to match totally different values and objects.

Whether or not you’re a seasoned PowerShell person or simply getting began, this information will assist you to perceive tips on how to Examine Strings in PowerShell parameters for simpler scripting and automation.

Strategies to Examine Strings in PowerShell

eq and ceq Operators – Equality

The ‘eq’ and ‘ceq’ comparability operators in PowerShell are used to check for equality between two values or objects. The ‘eq’ operator is used for case-insensitive comparability, whereas the ‘ceq’ operator is used for case-sensitive comparability. These operators are significantly helpful for evaluating strings and figuring out whether or not they match precisely or not.

To make use of the ‘eq’ operator, you merely place it between two values that you just need to examine. For instance, to examine if the string “Whats up” is the same as the string “howdy”, you might write:

"Whats up" -eq "howdy"

This may return ‘True’ as a result of the comparability is case-insensitive. To carry out a case-sensitive comparability, you should utilize the ‘ceq’ operator as a substitute. For instance:

"Whats up" -ceq "howdy"

This may return ‘False’ as a result of the comparability is now case-sensitive.

ceq Operator – Case Sensitivity

Testing for case-sensitive equality in PowerShell may be completed utilizing the “ceq” operator. The “ceq” operator stands for “case-sensitive equality” and it compares two strings for equality whereas taking into consideration their case.

For instance, suppose we have now a variable named $string with the worth “PowerShell”. We are able to take a look at for case-sensitive equality with the next code:

PS> $string -ceq "PowerShell"
True 
PS> $string -ceq "powershell"
False

On this instance, the primary comparability returns “True” as a result of the 2 strings are equal by way of their case, whereas the second comparability returns “False” as a result of the 2 strings aren’t equal by way of their case. It’s necessary to notice that the “ceq” operator is case-sensitive, so it won’t contemplate “PowerShell” and “powershell” to be equal.

ne and cne Operators – Inequality

The -ne operator checks if two values aren’t equal, whereas the -cne operator checks if two values aren’t equal in a case-sensitive method.

For instance, contemplate the next code:

PS> $value1 = 10
PS> $value2 = 20
PS> $value1 -ne $value2
True
PS> "PowerShell" -cne "powershell"
True

Within the first instance, we’re checking if $value1 just isn’t equal to $value2, which is true. Within the second instance, we’re checking if the string “PowerShell” just isn’t equal to the string “powershell” in a case-sensitive method, which can be true.

gt and ge Operators – Higher Than

In PowerShell, we are able to use the gt and ge operators to check whether or not one worth is larger than or equal to a different worth. These operators are generally utilized in conditional statements to make choices primarily based on the comparability of values.

The gt operator stands for “higher than” and returns $true if the left operand is larger than the suitable operand. For instance:

PS> 5 gt 3
True
PS> 3 gt 5
False

Equally, the ge operator stands for “higher than or equal to” and returns $true if the left operand is larger than or equal to the suitable operand. For instance:

PS> 5 ge 5

True

PS> 3 ge 5

False

These operators can be utilized with any worth varieties that may be in contrast. For instance, we are able to use them with integers, floats, and dates. Right here is an instance of utilizing gt and ge with dates:

PS> $right this moment = Get-Date

PS> $yesterday = $right this moment.AddDays(-1)

PS> $tomorrow = $right this moment.AddDays(1)

PS> $right this moment gt $yesterday

True

PS> $right this moment ge $tomorrow

False

Within the instance above, we examine the present date to the date from yesterday and tomorrow utilizing gt and ge. We are able to see that the gt operator returns $true for right this moment being higher than yesterday, and ge returns $false for right this moment being higher than or equal to tomorrow.

lt and le Operators – Much less Than

The lt and le operators in PowerShell are used to check whether or not one worth is lower than or lower than or equal to a different worth, respectively. These operators are usually used with numerical values, however they can be used with different varieties of values similar to strings or dates.

For instance, to check whether or not the worth of variable $a is lower than the worth of variable $b, you should utilize the lt operator as follows:

if ($a -lt $b) {
    # do one thing
}

Equally, to check whether or not the worth of variable $a is lower than or equal to the worth of variable $b, you should utilize the le operator as follows:

if ($a -le $b) {
    # do one thing
}

These operators are helpful for a wide range of duties in PowerShell scripting and can assist automate sure processes the place comparisons have to be made.

Checking Gadgets in a Assortment

Testing for gadgets in a group is a typical situation in PowerShell scripts. One technique to accomplish that is by utilizing the -contains and -notcontains operators.

For instance, let’s say we have now an array of numbers and we need to examine if a selected quantity is current within the array:

$numbers = 1, 2, 3, 4, 5
if ($numbers -contains 3) {
    Write-Host "The quantity 3 is current within the array."
}

On this instance, we use the -contains operator to examine if the quantity 3 is current within the $numbers array. Whether it is, we output a message to the console.

We are able to additionally use the -notcontains operator to examine if a quantity just isn’t current within the array:

$numbers = 1, 2, 3, 4, 5
if ($numbers -notcontains 6) {
    Write-Host "The quantity 6 just isn't current within the array."
}

On this instance, we use the -notcontains operator to examine if the quantity 6 just isn’t current within the $numbers array. If it isn’t, we output a message to the console.

Checking Collections to Include Values

Testing Collections to Include Values is a typical requirement in PowerShell scripts. As a way to do that, we use the -contains and -notcontains operators, which permit us to examine whether or not a group accommodates a particular worth or not.

For instance, let’s say we have now an array of numbers:

$numbers = 1, 2, 3, 4, 5

We are able to take a look at whether or not the quantity 3 is within the array utilizing the -contains operator like this:

if ($numbers -contains 3) {
    Write-Host "The quantity 3 is within the array"
}

We are able to additionally take a look at whether or not the quantity 6 just isn’t within the array utilizing the -notcontains operator like this:

if ($numbers -notcontains 6) {
    Write-Host "The quantity 6 just isn't within the array"
}

These operators can be used with different collections, similar to lists and hash tables, to check for the presence of particular values.

PowerShell Like Operator and Wildcards

In PowerShell, the Like operator is used to match values primarily based on wildcard characters. It’s much like the like operator in SQL and different programming languages.

The Like operator makes use of a number of wildcard characters to match the string values, similar to:

• * – Matches zero or extra characters.
• ? – Matches a single character.
• [] – Matches any single character throughout the brackets.
• - – Signifies a spread of characters throughout the brackets.
• ! – Negates a personality match throughout the brackets.

For instance, the next command will match any string that begins with “Pow” and ends with “erShell”:

PS> "PowerShell" -like "Pow*Shell"
True

Equally, the next command will match any string that begins with “Pow” and has a single character within the center:

PS> "PowerShell" -like "Pow?Shell"
True

The Like operator can be helpful when working with collections of values. For instance, to match an array of strings that include the phrase “PowerShell”, you should utilize the next command:

PS> $arr = @("Home windows PowerShell", "PowerShell Core", "PowerShell for Azure", "PowerShell for SharePoint")
PS> $arr -like "*PowerShell*"
True
True
True
True

On this instance, the * wildcard character is used to match any string that accommodates “PowerShell” in it. The result’s an array of 4 Boolean values indicating whether or not every aspect of the enter array matches the required sample.

Regex-based Matching

Along with the Like operator, PowerShell additionally helps sample matching primarily based on common expressions. Common expressions, or regex for brief, enable for extra superior sample matching primarily based on an outlined algorithm.

PowerShell supplies the -match and -notmatch operators for regex-based sample matching. These operators will let you match a string towards a regex sample and return a Boolean worth indicating whether or not the match was profitable.

For instance, you should utilize the -match operator to match a string towards a regex sample that appears for the presence of the phrase “PowerShell” adopted by any variety of digits:

PS> "I like PowerShell 7" -match "PowerShell d+"
True

On this instance, the sample “PowerShell d+” matches the string “PowerShell” adopted by a number of digits.

You may also use the -replace operator to interchange a regex sample with a brand new string:

PS> "PowerShell 7" -replace "d+", "5"
PowerShell 5

On this instance, the sample “d+” matches a number of digits within the string “PowerShell 7” and replaces them with the digit “5”.

In conclusion, PowerShell presents a variety of comparability parameters that can be utilized to check equality, inequality, and different situations for values and objects. By understanding the syntax and performance of those operators, PowerShell customers can create simpler scripts and automation routines.