PowerShell: Conditions

You'll need a condition first to compose intelligent PowerShell code capable of making decisions. That's why you'll learn in the first part of this Chapter how to formulate questions as conditions.

In the second part, you'll employ conditions to execute PowerShell instructions only if a particular condition is actually met.

Topics Covered:

• Formulating Conditions
  • Table 7.1: Comparison operators
  • Carrying Out a Comparison
  • "Reversing" Comparisons
  • Combining Comparisons
    • Table 7.2: Logical operators
  • Comparisons with Arrays and Collections
    • Verifying Whether an Array Contains a Particular Element
• Where-Object
  • Filtering Results in the Pipeline
  • Formulating a Condition
  • Using Alias
• If-ElseIf-Else
• Switch
  • Testing Range of Values
  • No Applicable Condition
  • Several Applicable Conditions
  • Using String Comparisons
    • Case Sensitivity
    • Wildcard Characters
    • Regular Expressions
  • Processing Several Values Simultaneously
• Summary

Formulating Conditions

A condition is nothing more than a question that can be answered clearly in the positive (true) or in the negative (false). Nearly all questions are phrased with the help of comparisons. The following PowerShell comparison operators allow you to compare values:

There are three variants of all comparison operators. The basic variant is case-insensitive when making comparisons. If you'd like to explicitly specify whether case sensitivity should be taken into account, use variants that begin with "c" (case-sensitive) or "i" (case-insensitive).

Carrying Out a Comparison

You can carry out comparisons immediately and directly in the PowerShell console. First, enter a value, then a comparison operator, and then the second value that you want to compare with the first. As soon as you hit (enter), the comparison will be performed. The result should always be True (condition is correct) or False (condition is incorrect).

As long as you compare only numbers or only strings, comparisons are very easy to grasp and return exactly the result that you expect:

However, you can also compare different data types. These results are not always as logical as the previous one:

Would you have expected these results? Some comparisons return peculiar results. That's precisely what happens when you compare different data types, and the reason is that PowerShell actually cannot compare different data types at all. PowerShell tries to convert the data types into a common data type that can be compared. However, this automatic conversion doesn't always return the result that you would intuitively expect, so you should avoid comparisons of differing data types.

"Reversing" Comparisons

A comparison always returns a result that is either true or false, and you've seen that there are complementary comparison operators for most comparisons: -eq and -ne (equal and not equal) or -gt and -lt (greater than and less than).

In addition, with the logical operator -not you have the option of "reversing" the result of a comparison. It expects an expression on the right side that is either true or false, and it turns this around. Instead of -not, you may also use the abbreviated "!":

Combining Comparisons

Because every comparison returns either True or False, you can combine several comparisons with logical operators. The following conditional statement would evaluate to true only if both comparisons evaluate to true:

Put separate comparisons in parentheses because you only want to link the results of these comparisons, certainly not the comparisons themselves.

Comparisons with Arrays and Collections

Up to now, you've only used the comparison operators in Table 7.1 to compare single values. In Chapter 4, you've already become familiar with arrays. The question is: how do comparison operators react to arrays? To which element of an array is the comparison applied? The simple answer: to all of them.

But the result is not a long list of True and False. In this case, comparison operators return an array in which precisely those elements of the initial array reappear in the matched comparison—resembling a sort of filter. In the simplest case, use the comparison operator -eq (equal) to find all elements in an array equal to the specified value:

Two elements having the value of 3 are in the initial array. Only these two elements were returned. It works conversely, too: if you'd like to see only the elements of an array that don't match the comparison value, use -ne (not equal) operator:

Verifying Whether an Array Contains a Particular Element

How can you find out whether an array contains a particular element? As you have seen, -eq provides no answer to this question. That's why there are the comparison operators -contains and -notcontains. They verify whether a certain value exists in an array.

Where-Object

Let's now apply conditions in real life. The first area of application is the PowerShell pipeline, which you became acquainted with in Chapter 5. In the pipeline, the results of a command are forwarded directly to the next one, and the Where-Object cmdlet works like a filter, allowing only those objects through the pipeline that meet a certain condition. To make this work, specify your condition to Where-Object.

Filtering Results in the Pipeline

The cmdlet Get-Process, will return all running processes. However, you are not likely to be interested in all processes, but instead you want an answer to a specific problem. For instance, you would like to find out currently running instances of the Notepad. First, get an initial overview of which properties the processes contain by using Get-Process. That's important, because you'll use these properties afterwards as the basis for your condition. This is how you can find the available properties:

Get-Process | Select-Object -first 1 | Format-List *
__NounName                 : Process
Name                       : agrsmsvc
Handles                    : 36
VM                         : 21884928
WS                         : 57344
PM                         : 716800
NPM                        : 1768
Path                       :
Company                    :
CPU                        :
FileVersion                :
ProductVersion             :
Description                :
Product                    :
Id                         : 1316
PriorityClass              :
HandleCount                : 36
WorkingSet                 : 57344
PagedMemorySize            : 716800
PrivateMemorySize          : 716800
VirtualMemorySize          : 21884928
TotalProcessorTime         :
BasePriority               : 8
ExitCode                   :
HasExited                  :
ExitTime                   :
Handle                     :
MachineName                : .
MainWindowHandle           : 0
MainWindowTitle            :
MainModule                 :
MaxWorkingSet              :
MinWorkingSet              :
Modules                    :
NonpagedSystemMemorySize   : 1768
NonpagedSystemMemorySize64 : 1768
PagedMemorySize64          : 716800
PagedSystemMemorySize      : 24860
PagedSystemMemorySize64    : 24860
PeakPagedMemorySize        : 716800
PeakPagedMemorySize64      : 716800
PeakWorkingSet             : 2387968
PeakWorkingSet64           : 2387968
PeakVirtualMemorySize      : 21884928
PeakVirtualMemorySize64    : 21884928
PriorityBoostEnabled       :
PrivateMemorySize64        : 716800
PrivilegedProcessorTime    :
ProcessName                : agrsmsvc
ProcessorAffinity          :
Responding                 : True
SessionId                  : 0
StartInfo                  : System.Diagnostics.ProcessStartInfo
StartTime                  :
SynchronizingObject        :
Threads                    : {1964, 1000}
UserProcessorTime          :
VirtualMemorySize64        : 21884928
EnableRaisingEvents        : False
StandardInput              :
StandardOutput             :
StandardError              :
WorkingSet64               : 57344
Site                       :
Container                  :

Formulating a Condition

The name of a process can be found in the Name property. If you're just looking for the processes of the Notepad, your condition should be name -eq 'notepad'. Now, supply this condition to Where-Object:

Handles NPM(K) PM(K) WS(K) VM(M) CPU(s)   Id ProcessName
------- ------ ----- ----- ----- ------   -- -----------
     68      4  1636  8744    62   0,14 7732 notepad
     68      4  1632  8764    62   0,05 7812 notepad

The pipeline now returns only those processes that meet your condition. If you're not currently running the Notepad, nothing will be returned. If you take a closer look at Where-Object, you'll see that your condition is specified in braces after the cmdlet. The $_ variable contains the current pipeline object.

The next one-liner would retrieve all processes whose company name begins with "Micro" and output for each process its name, description, and company name:

Name           Description                 Company
----           -----------                 -------
conime         Console IME                 Microsoft Corporation
dwm            Desktopwindow-Manager       Microsoft Corporation
ehmsas         Media Center Media Statu... Microsoft Corporation
ehtray         Media Center Tray Applet    Microsoft Corporation
EXCEL          Microsoft Office Excel      Microsoft Corporation
explorer       Windows-Explorer            Microsoft Corporation
GrooveMonitor  GrooveMonitor Utility       Microsoft Corporation
ieuser         Internet Explorer           Microsoft Corporation
iexplore       Internet Explorer           Microsoft Corporation
msnmsgr        Messenger                   Microsoft Corporation
notepad        Editor                      Microsoft Corporation
notepad        Editor                      Microsoft Corporation
sidebar        Windows-Sidebar             Microsoft Corporation
taskeng        Task Scheduler Engine       Microsoft Corporation
WINWORD        Microsoft Office Word       Microsoft Corporation
wmpnscfg       Windows Media Player Net... Microsoft Corporation
wpcumi         Windows Parental Control... Microsoft Corporation

Using Alias

Because you often need conditions in the pipeline, an alias exists for Where-Object: "?". So, instead of Where-Object, you may also use "?'".

If-ElseIf-Else

Where-object works splendidly in the pipeline, but it is inappropriate if you want to make longer code segments dependent on meeting a condition. Here, the If..ElseIf..Else statement works much better. In the simplest case, the statement looks like this:

If (condition) {
  # If the condition applies, 
  # this code will be executed
}

The condition must be enclosed in parentheses and follow the keyword If. If the condition is met, the code in the braces after it will be executed, otherwise not. Try it out:

If ($a -gt 10) { "$a is larger than 10" }

It's likely, though, that you won't (yet) see a result. The condition was not met, and so the code in the braces wasn't executed. To get an answer, make sure that the condition is met:

$a = 11 
If ($a -gt 10) { "$a is larger than 10" } 

Now the comparison is correct, and the If statement ensures that the code in the braces returns a result. As it is, that clearly shows that the simplest If statement usually doesn't suffice in itself, because you would like to always get a result, even when the condition isn't met. To accomplish that, expand the If statement with Else:

Now the code in the braces after If is executed if the condition is met; if the preceding condition isn't true, the code in the braces after Else is executed. If you have several conditions you may insert as many ElseIf blocks between If and Else as you like:

If ($a -gt 10) 
{
  "$a is larger than 10"
} 
ElseIf ($a -eq 10) 
{
  "$a is exactly 10"
} 
Else 
{
  "$a is less than 10"
}

The If statement here always executes the code in the braces after the condition that is met. The code after Else will be executed when none of the preceding conditions are true. What happens if several conditions are true? Then the code after the first applicable condition will be executed and all other applicable conditions will be ignored.

If ($a -gt 10) 
{
  "$a is larger than 10"
} 
ElseIf ($a -eq 10) 
{
  "$a is exactly 10"
} 
ElseIf ($a -ge 10) 
{
  "$a is larger than or equal to 10"
} 
Else 
{
  "$a is smaller than 10"
}

# Returns True from 14:00 on, otherwise False:
Function isAfternoon { (Get-Date).Hour -gt 13 }
isAfternoon
True
# Result of the function determines which code the If statement executes:
If (isAfternoon) { "Time for break!" } Else { "It's still early." }
Time for break!

Switch

If you'd like to test a value against many comparison values, the If statement could quickly become confusing. The Switch statement is much clearer and quicker:

# Test a value against several comparison values (with If statement):
$value = 1
If ($value -eq 1)
{
  " Number 1"
}
ElseIf ($value -eq 2)
{
  " Number 2"
}
ElseIf ($value -eq 3)
{
  " Number 3"
}
Number 1
# Test a value against several comparison values (with Switch statement):
$value = 1
Switch ($value)
{
  1  { "Number 1" }
  2  { "Number 2" }
  3  { "Number 3" }
}
Number 1

This is how to use the Switch statement: the value to switch on is in the parentheses after the Switch keyword. That value is matched with each of the conditions case by case. If a match is found, the action associated with that condition is performed. Default comparison operator is the -eq operator to verify equality.

Testing Range of Values

The default comparison operator is -eq operator, but you could also compare a value with your own conditions. Formulate your own condition and put it in braces. Condition must result in either true or false:

$value = 8
Switch ($value)
{
  # Instead of a standard value, a code block is used 
  # that results in True for numbers smaller than 5:
  {$__-le 5}  { "Number from 1 to 5" }

  # A value is used here; Switch checks whether this 
  # value matches $value:
  6  { "Number 6" }

  # Complex conditions are allowed as they are here, 
  # where -and is used to combine two comparisons:
  {(($__-gt 6) -and ($__-le 10))} { "Number from 7 to 10" }
}
Number from 7 to 10

• The code block {$_ -le 5} includes all numbers less than or equal to 5.
• The code block {(($_ -gt 6) -and ($_ -le 10))} combines two conditions and results in true if the number is either larger than 6 or less than-equal to 10. Consequently, you may combine any PowerShell statements in the code block and also use the logical operators listed in Table 7.2.

Here, you used the initial value stored in $_ for your conditions, but because $_ is generally available anywhere in the Switch block, you could just as well have put it to work in the result code:

$value = 8
Switch ($value)
{
  # The initial value (here it is in $value) 
  # is available in the variable $_:
  {$_ -le 5}  { "$_ is a number from 1 to 5" }
  6  { "Number 6" }
  {(($_ -gt 6) -and ($_ -le 10))}  
    { "$_ is a number from 7 to 10" }
}
8 is a number from 7 to 10

No Applicable Condition

In a similar manner as an If statement, the Switch statement executes code only if at least one of the specified conditions is met. The keyword, which for the If statement is called Else, is called default for Switch statement. When no other condition matches, the default clause is run.

$value = 50
Switch ($value)
{
  {$_ -le 5}  { "$_is a number from 1 to 5" }
  6  { "Number 6" }
  {(($_ -gt 6) -and ($_ -le 10))}  
    { "$_ is a number from 7 to 10" }
  # The code after the next statement will be 
  # executed if no other condition has been met:
  default {"$_ is a number outside the range from 1 to 10" }
}
50 is a number outside the range from 1 to 10

Several Applicable Conditions

If more than one condition applies, then Switch will behave differently than If. For If, only the first applicable condition was executed. For Switch, all applicable conditions are executed:

$value = 50
Switch ($value)
{
  50  { "the number 50" }
  {$_ -gt 10}  {"larger than 10"}
  {$_ -is [int]}  {"Integer number"}
}
The Number 50
Larger than 10
Integer number

Consequently, all applicable conditions ensure that the following code is executed, and so in some circumstances you may get more than one result.

If you'd like to receive only one result, while consequently making sure that only the first applicable condition is performed, then append the break statement to the code.

$value = 50
Switch ($value)
{
  50  { "the number 50"; break }
  {$_ -gt 10}  {"larger than 10"; break}
  {$_ -is [int]}  {"Integer number"; break}
}
The number 50

In fact, now you get only the first applicable result. The keyword break indicates that no more processing will occur and the Switch statement will exit.

Using String Comparisons

The previous examples have always compared numbers. You could also naturally compare strings since you now know that behind the scenes Switch uses only the normal -eq comparison operator and that there string comparisons are also permitted. The following code could be the basic structure of a command evaluation. A different action will be performed, depending on the specified command:

$action = "sAVe"
Switch ($action)
{
  "save"  { "I save..." }
  "open"  { "I open..." }
  "print"  { "I print..." }
  Default  { "Unknown command" }
}
I save...

Case Sensitivity

Since the -eq comparison operator doesn't distinguish between lower and upper case, case sensitivity doesn't play any role in comparisons. If you want to distinguish between them, then use the -case option. Working behind the scene, it will replace the -eq comparison operator with -ceq, after which case sensitivity will suddenly become crucial:

$action = "sAVe"
Switch -case ($action)
{
  "save"  { "I save..." }
  "open"  { "I open..." }
  "print"  { "I print..." }
  Default  { "Unknown command" }
}
Unknown command

Wildcard Characters

In fact, you can also exchange a standard comparison operator for -like and -match operators and then carry out wildcard comparisons. Using the -wildcard option, activate the -like operator, which is conversant, among others, with the "*" wildcard character:

$text = "IP address: 10.10.10.10"
Switch -wildcard ($text)
{
  "IP*"  { "The text begins with IP: $_" }
  "*.*.*.*"  { "The text contains an IP " +
               "address string pattern: $_" }
  "*dress*"  { "The text contains the string " +
               "'dress' in arbitrary locations: $_" }
}
The text begins with IP: IP address: 10.10.10.10 
The text contains an IP address string pattern: 
  IP address: 10.10.10.10
The text contains the string 'dress' in arbitrary 
  locations: IP address: 10.10.10.10

Regular Expressions

Simple wildcard characters can't always be used for recognizing patterns. Regular expressions are much more efficient. But they assume much more basic knowledge, a reason for you to now take a peek ahead at Chapter 13, which discusses regular expression in greater detail.

With the -regex option, you can ensure that Switch uses the -match comparison operator instead of -eq, and thus employs regular expressions. Using regular expressions, you can identify a pattern much more precisely than by using simple wildcard characters. But that's not all: as was the case with the -match operator, you will usually get back the text that matches the pattern in the $matches variable. This way, you could even parse information out of the text:

$text = "IP address: 10.10.10.10"
Switch -regex ($text)
{
  "^IP"  { "The text begins with IP: " +
    "$($matches[0])" }
  "\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}" { 
    "The text contains an IP address " +
    "string pattern: $($matches[0])" }
  "\b.*?dress.*?\b"  { " The text " +
    "contains the string 'dress' in " +
    "arbitrary locations: $($matches[0])" }
}
The text begins with IP: IP
The text contains an IP address string 
  pattern: 10.10.10.10
The text contains the string 'dress' in 
  arbitrary locations: IP address

Processing Several Values Simultaneously

Until now, you have always passed to Switch just one value for evaluation. But Switch can also process several values at the same time. To do so, pass to Switch the values in an array or a collection. In the following example, Switch is passed an array containing five elements. Switch automatically takes all the elements one at a time from the array and compares each of them, one by one:

$array = 1..5
Switch ($array)
{
  {$_ % 2} { "$_ is odd."}
  Default { "$_ is even."}
}
1 is odd.
2 is even.
3 is odd.
4 is even.
5 is odd.

There you have it: Switch accepts not only single values but also entire arrays and collections. As such, Switch would actually be an ideal candidate for evaluating results on the PowerShell pipeline because the pipeline character ("|") is used to forward results as arrays or collections from one command to the next.

The next line queries Get-Process for all running processes and pipes the result to a script block (& {...}). In the script block, Switch evaluates the result of the pipeline, which is available in $input. If the WS property of a process is larger than one megabyte, this process is output Switch will filter all the processes whose WS property is less than or equal to one megabyte:

Get-Process | & { Switch($input) { {$_.WS -gt 1MB} { $_ }}}

However, this line is extremely hard to read and seems complicated. By using Where-Object, you can formulate the condition in a much clearer way:

Get-Process | Where-Object { $_.WS -gt 1MB }

This variant is also quicker because Switch had to wait until the pipeline had collected the entire results of the preceding command in $input. In Where-Object, it processes the results of the preceding command precisely when the results are ready. This difference is especially striking for elaborate commands:

# Switch returns all files beginning with "a":
Dir | & { Switch($input) { 
  {$_.name.StartsWith("a")} { $_ } }}

# But it doesn't do so until Dir has retrieved 
# all data, and that can take a long time:
Dir -Recurse | & { Switch($input) { 
  {$_.name.StartsWith("a")} { $_ } }}

# Where-Object processes the incoming results 
# immediately:
Dir -recurse | Where-Object { 
  $_.name.StartsWith("a") }

# The alias of Where-Object ("?") works 
# exactly the same way:
Dir -recurse | ? { $_.name.StartsWith("a") }

Summary

Intelligent decisions are based on conditions, which in the simplest form can be reduced to plain Yes or No answers. Using the comparison operators listed in Table 7.1, you can formulate such conditions and can even combine these with the logical operators listed in Table 7.2 to form complex queries.

The simple Yes/No answers of your conditions determine whether particular PowerShell instructions should be carried out or not. In the simplest form, you can use the Where-Object cmdlet in the pipeline. It functions there like a filter, allowing only those results through the pipeline that correspond to your condition.

If you would like more control, or would like to execute larger code segments independently of conditions, use the If statement, which evaluates as many different conditions as you wish and, depending on the result, executes the allocated code. This is the typical "If-Then" scenario: if certain conditions are met, then certain code segments will be executed.

An alternative to the If statement is the Switch statement: using it, you can compare a fixed initial value with various possibilities. Switch is the right choice when you want to check a particular variable against many different possible values.