Topic: Switch Statement II

Notice: This post is a part of the PowerShell Monday series — a group of quick and easy to read mini lessons that briefly cover beginning and intermediate PowerShell topics. As a PowerShell enthusiast, this seemed like a beneficial way to ensure those around me at work were consistently learning new things about Windows PowerShell. At some point, I decided I would share these posts here, as well. Here’s the PowerShell Monday Table of Contents.

Okay, we’re back with more information on the Switch language construct. We’ll start where we left off: getting the Switch to act more like the If statement. In our first example we’ll do just that, and we do it with the break statement.

Switch (3) {
    1 {'One'}
    2 {'Two'}
    3 {'Three'; break}
    4 {'Four'}
    3 {'Three (again)'}
}

Three

With the inclusion of the break statement, we exit the Switch construct the moment our condition is matched and action is completed.

Typically, I’ll include several break statements in my Switch statements. This is because once my condition is matched and the action completed, I’m typically ready to move past my Switch. In the below example, we’ll exit the Switch the moment a match is made and the action complete.

Switch (3) {
    1 {'One'; break}
    2 {'Two'; break}
    3 {'Three'; break}
    4 {'Four'}
}

Notice that I didn’t use a break statement on the last condition. It doesn’t make sense to include it. If we make it down to the last possible condition, I can be certain it’s not going to check anymore conditions, as there aren’t any more to check.

The switch statement can check collections, too. In this example, we evaluate the test-value of 4, and then the test-value of 2.

Switch (4,2) {
    1 {'One'}
    2 {'Two'}
    3 {'Three'}
    4 {'Four'}
    5 {'Five'}
}

Four
Two

It’s probably a good time to indicate that the break statement can break things, as well. It’s not always a good idea that it’s used. In this next example, 2 is never evaluated because we exit the Switch the moment the action for 4 is complete.

Switch (4,2) {
    1 {'One'; break}
    2 {'Two'; break}
    3 {'Three'; break}
    4 {'Four'; break}
    5 {'Five'}
}

Four

That’s it for today. We have at least one more PSMonday dedicated to the Switch. Maybe two. Okay, probably two.

Topic: Switch Statement

Notice: This post is a part of the PowerShell Monday series — a group of quick and easy to read mini lessons that briefly cover beginning and intermediate PowerShell topics. As a PowerShell enthusiast, this seemed like a beneficial way to ensure those around me at work were consistently learning new things about Windows PowerShell. At some point, I decided I would share these posts here, as well. Here’s the PowerShell Monday Table of Contents.

The Switch language construct, also called the case statement in other languages, is a close relative to the If statement and its variations. As you work with If, be sure to consider Switch, as it can assist in a cleaner layout, and therefore, more easily read code. As mentioned previously, if your If statements are going past three levels, consider the Switch.

To start, here’s the basic, conceptual format. We consider a test-value in the parenthesis, determine the matching condition on the left, and then execute its corresponding action on the right.

Switch (<test-value>) {
    <condition> {<action>}
    <condition> {<action>}
    <condition> {<action>}
}

To begin, here’s a very basic example. We evaluate the test-value — it’s just a numeric 3 — and then find the matching condition. Once found (the 3 in our list of conditions), we’ll take the corresponding action, and write the word “Three” to the screen. Simple.

Switch (3) {
    1 {'One'}
    2 {'Two'}
    3 {'Three'}
    4 {'Four'}
}

Three

Our test-value can also be an equation: 2 + 2 (= 4) and then down through the possible conditions, and take the appropriate action.

Switch (2 + 2) {
    1 {'One'}
    2 {'Two'}
    3 {'Three'}
    4 {'Four'}
}

Four

There’s something we need to understand about the Switch construct, and that is that it is designed to look at all the conditions, no matter if it’s found one already, or not. Take a look at this example for clarification.

Switch (3) {
    1 {'One'}
    2 {'Two'}
    3 {'Three'}
    4 {'Four'}
    3 {'Three (again).'}
    5 {'Five'}
}

Three
Three (again).

In the above example, we can easily see that although it found 3 in the list of conditions, it continued looking through the additional conditions, only to find another one that matched. What we should have done, is just included multiple commands inside the action, like the following two examples. Notice that in the first example, we use the semi-colon as a command separator, and in the second example, we use the line break (Enter).

Switch (3) {
    1 {'One'}
    2 {'Two'}
    3 {'Three'; 'Three (again, but not really).'}
    4 {'Four'}
}

Three
Three (again, but not really).

Switch (3) {
    1 {'One'}
    2 {'Two'}
    3 {'Three'
       'Three (again, but not really).'
    }
    4 {'Four'}
}

Three
Three (again, but not really).

Make sure you fully understand these examples before next week. We’ll start that PSMonday in an effort to show how to get our Switch statements to act a bit more like the If statement, to exit when our condition is matched, and action taken.

Topic: If, If-Else, If-ElseIf III

Notice: This post is a part of the PowerShell Monday series — a group of quick and easy to read mini lessons that briefly cover beginning and intermediate PowerShell topics. As a PowerShell enthusiast, this seemed like a beneficial way to ensure those around me at work were consistently learning new things about Windows PowerShell. At some point, I decided I would share these posts here, as well. Here’s the PowerShell Monday Table of Contents.

I failed to mention something last week. While I wouldn’t recommend you do it, you can rewrite this:

If (-Not(<condition>)) {
    <action>
}

to be this:

If (!(<condition>)) {
    <action>
}

I’m not mentioning this because you should use ! over -Not (ever, honestly), but just in case you see it being used. As I believed we’ve mentioned before, we only use aliases in onetime use scenarios, such as when you’re entering commands in your ConsoleHost or the ISE and have no intention of saving what you’ve entered. The ! is not a true alias, but it’s close enough to consider it one. This is a PowerShell community best practice, and one I’ll continue to pound in, at every opportunity I have.

Okay, on with this week’s If wrap-up.

Let’s get away from these conceptual examples. In this first example, we’ll assign values to two variables: $y will hold the numeric value of 5, and $z will hold the numeric value of 3. When we enter the If statement, we check both values. If both — and that’s key — of their values match, we’ll echo the word “If.”

$y = 5; $z = 3

If ($y -eq 5 -and $z -eq 3) {
    Write-Output -InputObject 'If'
}

If

Had we used the -or comparison operator, it would’ve echoed “If,” as well. Or, means that only one of the conditions would have to result In True.

If ($y -eq 5 -or $z -eq 10) {
    Write-Output -InputObject 'If'
}

If

In the above example, only $y -eq 5 was True. As mentioned, since we used the -or operator, only one of those conditions needed to result in True for the condition to pass. The below example uses the -and comparison operator again; however, the end results is False, so the Else portion of the If-Else is executed.

$y = 5; $z = 3

If ($y -eq 5 -and $z -eq 2) {
    Write-Output -InputObject 'If'
} Else {
    Write-Output -InputObject 'Else'
}

Else

Pretty straightforward. Let’s modify the above examples and make our Else, and ElseIf. When this example executes, the If portion will be False ($z was not assigned a numeric value of 2), so the ElseIf condition will be checked. This will result in True, as $z was assigned a numeric value of 3.

$y = 5; $z = 3

If ($y -eq 5 -and $z -eq 2) {
    Write-Output -InputObject 'If'
} ElseIf ($y -eq 5 -and $z -eq 3) {
    Write-Output -InputObject 'ElseIf'
}

ElseIf

In our final example we’ll include two ElseIf conditions. Notice in this example, that once the first one results in True, we exit the construct. That final ElseIf, while it would have also resulted in True, isn’t even considered. While we won’t go into it for now, you can nest language constructs. This is to say, we could’ve added another If statement inside the action portion of the ElseIf, and tested for $z -eq 3.

$y = 5; $z = 3

If ($y -eq 5 -and $z -eq 2) {
    Write-Output -InputObject 'If'
} ElseIf ($y -eq 5) {
    Write-Output -InputObject 'ElseIf 1' # Exits If-ElseIf.
} ElseIf ($z -eq 3) {
    Write-Output -InputObject 'ElseIf 2'
}

ElseIf 1

We’re going to end here with the If language construct, and start fresh with the Switch statement next Monday. I encourage you to ask any questions you might have about the If statement, as it’s vital you have a good understanding of this introductory language command.

Keep in mind the examples could’ve been much different than just comparing numbers. We could have return services and taken action based on whether a service was located, or not, or running or stopped. We could have returned a specific Active Directory user and taken action based on whether we found the user, or not. The list goes on.

Topic: If, If-Else, If-ElseIf

Notice: This post is a part of the PowerShell Monday series — a group of quick and easy to read mini lessons that briefly cover beginning and intermediate PowerShell topics. As a PowerShell enthusiast, this seemed like a beneficial way to ensure those around me at work were consistently learning new things about Windows PowerShell. At some point, I decided I would share these posts here, as well. Here’s the PowerShell Monday Table of Contents.

Time to start learning, or reviewing, those language constructs — those “language commands,” as is the term used in the If statement’s, about topic help file. This file can be read by using the below command.

Get-Help -Name about_If

The If statement is typically the introductory control structure that someone encounters when they begin with a programming, or scripting, language. It is also the one people likely think of first when they need to start checking conditions and taking appropriate actions.

Here’s the basic, PowerShell If structure. We check a condition, and if it’s true, then we take the included action, or actions.

If (<condition>) {
    <action>
}

There are several variations of the If statement: Here’s the If-Else. This is much like the If, except that if the condition results in false, it would complete action2 instead of exiting the construct and ultimately doing nothing. Had the condition been true, it would’ve completed action1, as we saw in the first example.

If (<condition>) {
    <action>
} Else {
    <action2>
}

Here’s the If-ElseIf. The way this works is if condition1 is false, it will try condition2. If that’s true, it’ll run action2, but if it’s false, it’ll exit and take no action.

If (<condition1>) {
     <action1>
} ElseIf (<condition2>) {
    <action2>
}

If-ElseIf-Else is just like the above example; however, if condition2 resulted in false, it would complete action3 as the default action.

If (<condition1>) {
    <action1>
} ElseIf (<condition2>) {
    <action2>
} Else {
    <action3>
}

There’s really no limit to how many ElseIfs you include. Just keep in mind that Else completes a default action, as there’s no condition to check, while ElseIf requires a condition be checked (and be true), before the listed action is completed.

On a final note, if you’re going past three levels in your If constructs, then you may want to use the Switch statement. We’ll get to that one once we’ve completely knocked out the If.

Topic: Introduction to the Language Constructs

Notice: This post is a part of the PowerShell Monday series — a group of quick and easy to read mini lessons that briefly cover beginning and intermediate PowerShell topics. As a PowerShell enthusiast, this seemed like a beneficial way to ensure those around me at work were consistently learning new things about Windows PowerShell. At some point, I decided I would share these posts here, as well. Here’s the PowerShell Monday Table of Contents.

I’ve long had this feeling that people that learn and use PowerShell don’t really ever get  a fair opportunity, to learn the language constructs. Instead, they just learn them as necessary. In an effort to correct this, I believe we should spend some time in the coming weeks, covering each of them.

Well then, what’s a language construct, right? Well, it’s a control structure, of course. Okay, well then what’s that?

Within a language — PowerShell in our instance — we have to have a way to handle conditional situations, in order to take appropriate action(s). Language constructs are the If statement and its variations, it’s the switch statement, it’s the foreach loop and ForEach-Object, the for, the Do variations, and the While loop, too.

In the coming weeks, we’ll spend some time with each of the constructs, so that you’ve seen and used them all, or simply reviewed them, if you’ve used them before. Knowing which to use when, is a vital skill, and best left to second nature once you’ve had experience with them all. I’ll be sure to include some of the times you might choose one over the other, when you can do the same thing with more than just one of the constructs. We’ll start next Monday with If, If-Else, and If-ElseIf.