200
CHAPTER 6
F
LOW
CONTROL
IN
SCRIPTS
6.1
T
HE
CONDITIONAL
STATEMENT
PowerShell has one main conditional statement: the 
if
statement shown in figure 6.2.
This statement lets a script decide whether an action should be performed by eval-
uating a conditional expression, then selecting the path to follow based on the results 
of that evaluation. The PowerShell 
if
statement is similar to the 
if
statement found 
in most programming languages. The one thing that’s a bit different syntactically is 
the use of 
elseif
as a single keyword for subsequent clauses. Figure 6.3 shows the 
structure and syntax of this statement in detail.
Let’s work through some examples that illustrate how the 
if
statement works. 
You’ll use all three of the elements—
if
elseif
, and 
else
—in this example:
if ($x -gt 100) 
{
"It's greater than one hundred" 
elseif ($x -gt 50) 
{
"It's greater than 50" 
} else 
{
"It's not very big." 
}
In this example, if the variable 
$x
holds a value greater than 100, the string “It’s 
greater than one hundred” will be emitted. If 
$x 
is greater than 50 but less than 100, 
it will emit “It’s greater than 50”; otherwise, you’ll get “It’s not very big.” Of course,
if ( <expr> ) { <statements> } 
if ( <expr> ) { <statements> } else { <statements> } 
if ( <expr> ) { <statements> } elseif ( <expr> ) { <statements> } else { <statements> }
Conditional statements
Figure 6.2 The syntax of the PowerShell conditional statements
if (<pipeline>) {<statementList>} elseif (<pipeline>) {<statementList>} else {<statementList>}
if keyword
Executed when if
condition is true
Pipeline to test, enclosed in
parentheses
else keyword
Executed when elseif
condition is true
Braces marking beginning and
end of blocks
elseif keyword
elseif pipeline to test
Figure 6.3 PowerShell’s version of the 
if
statement, which is the basic conditional state-
ment found in all scripting and programming languages
Pdf rearrange pages - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
how to rearrange pdf pages online; reorder pages in pdf online
Pdf rearrange pages - VB.NET PDF Page Move Library: re-order PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sort PDF Document Pages Using VB.NET Demo Code
rearrange pdf pages reader; how to move pages in a pdf
T
HE
CONDITIONAL
STATEMENT
201
you can have zero or more 
elseif
clauses to test different things. The 
elseif
and 
else
parts are optional, as is the case in other languages.
As you might have noticed, the PowerShell 
if
statement is modeled on the 
if 
statement found in 
C
-derived languages, including 
C
#, but a couple of differences 
exist. First, 
elseif
is a single keyword with no spaces allowed between the words. 
Second, the braces are mandatory around the statement lists, even when you have 
only a single statement in the list (or no statements for that matter, in which case you 
would have to type 
{}
). If you try to write something like
if ($x -gt 100) "It's greater than one hundred"
you’ll get a syntax error:
PS (1) > if ($x -gt 100) "It's greater than one hundred" 
Missing statement block after if ( condition ).
At line:1 char:17 
+ if ($x -gt 100) " <<<< It's greater than one hundred" 
PS (2) >
In general, the syntax of the 
if
statement (and all the PowerShell flow-control state-
ments) is freeform with respect to whitespace. In other words, you can lay out your 
code pretty much any way you want. You can write an 
if
statement that looks like this
if($true){"true"}else{"false"}
with no whitespace whatsoever. Alternatively, you could also write it like this
if 
$true 
"true" 
else
Grammar lessons
The PowerShell grammar technically could support the construction shown in the 
preceding example. In fact, we did enable this feature at one point, but when people 
tried it out, it resulted in a lot of errors. The problem is that a newline or a semicolon is 
required to terminate a  command.  This leads to the situation where  you write 
something like
if ($x -gt 3) write x is $x while ($x--) $x
and discover that, because you’ve missed the semicolon before the while statement, 
it writes out the while statement instead of executing it. In the end, the cost of typing 
a couple of additional characters was more than offset by a decreased error rate. For 
this reason, the language design team decided to make the braces mandatory.
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
C# TIFF - Sort TIFF File Pages Order in C#.NET. Reorder, Rearrange and Sort TIFF Document Pages in C#.NET Application. C# TIFF Page Sorting Overview.
how to move pages within a pdf document; pdf rearrange pages online
VB.NET TIFF: Modify TIFF File by Adding, Deleting & Sort TIFF
you want to change or rearrange current TIFF &ltsummary> ''' Sort TIFF document pages in designed powerful & profession imaging controls, PDF document, image
how to reorder pages in pdf; how to move pages in pdf reader
202
CHAPTER 6
F
LOW
CONTROL
IN
SCRIPTS
{
"false" 
}
where each element is on a separate line. 
There’s one constraint on how you can format an 
if
statement: when PowerShell 
is being used interactively, the 
else
or 
elseif
keyword has to be on the same line as 
the previous closing brace; otherwise, the interpreter will consider the statement com-
plete and execute it immediately.
It’s important to note that the PowerShell 
if
statement allows a pipeline in the con-
dition clause, not just a simple expression. This means it’s possible to do the following:
if ( dir telly*.txt | select-string penguin ) 
{
"There's a penguin on the telly." 
}
In this example, the pipeline in the condition part of the 
if
statement will scan all 
the text files whose names start with “telly” to see whether they contain the word 
“penguin.” If at least one of the files contains this word, the statement block will be 
executed, printing out
There's a penguin on the telly.
Here’s another example:
if (( dir *.txt | select-string -List spam ).Length -eq 3) 
{
"Spam! Spam! Spam!" 
}
In this case, you search all the text files in the current directory looking for the word 
“spam.” If exactly three files contain this word, then you print out
Spam! Spam! Spam!
NOTE
Yes, these are, in fact, Monty Python references. This is where 
the Python language got its name. If you’re familiar with Python or 
Perl, you’ll occasionally recognize cultural references from those lan-
guages in PowerShell examples here and elsewhere. Many of the Pow-
erShell development team members had their first scripting experiences 
with those languages. 
Because you can use pipelines and subexpressions in the conditional part of an 
if 
statement, you can write quite complex conditional expressions in PowerShell. With 
subexpressions, you can even use an 
if
statement inside the condition part of another 
if
statement. Here’s what this looks like:
PS (2) > $x = 10
PS (3) > if ( $( if ($x -lt 5) { $false } else { $x } ) -gt
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
page directly. Moreover, when you get a PDF document which is out of order, you need to rearrange the PDF document pages. In these
change page order in pdf online; pdf reverse page order online
Online Merge PDF files. Best free online merge PDF tool.
the button below and download your PDF. The perfect conversion tool. By dragging your pages in the editor area you can rearrange them or delete single pages.
pdf reorder pages online; reverse pdf page order online
L
OOPING
STATEMENTS
203
>>> 20) { $false } else {$true}
True 
PS (4) > $x = 25 
PS (5) > if ( $( if ($x -lt 5) { $false } else { $x } ) -gt 
>>> 20) { $false } else {$true}
False 
PS (6) > $x = 4 
PS (7) > if ( $( if ($x -lt 5) { $false } else { $x } ) -gt 
>>> 20) { $false } else {$true}
True 
PS (8) >
If looking at this makes your head hurt, welcome to the club—it made mine hurt to 
write it. Let’s dissect this statement and see what it’s doing. Let’s take the inner 
if 
statement first:
if ($x -lt 5) { $false } else { $x }
You can see that this statement is straightforward. If 
$x
is less than the number 5, it 
returns false; otherwise, it returns the value of 
$x
. Based on this, let’s split the code 
into two separate statements:
$temp = $( if ($x -lt 5) { $false } else { $x } ) 
if ($temp -gt 20) { $false } else {$true}
What the outer 
if
statement is doing is also pretty obvious: if the result of the first 
(formally inner) statement is greater than 20, return 
$false
; otherwise return 
$true
Now that you can do branching, let’s move on to the looping statements.
6.2
L
OOPING
STATEMENTS
Looping is the ability to repeat a set of actions some specific number of times, either 
based on a count or a condition expression. The PowerShell loop statements cover 
both of these cases and are shown in figure 6.4.
6.2.1
The while loop
In this section, we’ll cover the basic looping statement in PowerShell: the 
while
state-
ment. The 
while
statement (also known as a 
while
loop) is the most basic Power-
Shell  language  construct  for  creating  a  loop.  It  executes  the  commands  in  the
while ( <expr> ) { <statements> } 
do { <statements> } while ( <expr> ) 
do { <statements> } until ( <expr> ) 
for ( <expr> ; <expr> ; <expr> ) { <statements> }
foreach ( $var in <pipeline> ) { <statements> }
Loop statements
Figure 6.4 The PowerShell loop statements
C# PowerPoint - How to Process PowerPoint
pages simply with a few lines of C# code. C# Codes to Sort Slides Order. If you want to use a very easy PPT slide dealing solution to sort and rearrange
how to reorder pdf pages in; move pages within pdf
VB.NET Word: How to Process MS Word in VB.NET Library in .NET
well programmed Word pages sorter to rearrange Word pages in extracting single or multiple Word pages at one & profession imaging controls, PDF document, image
how to rearrange pdf pages reader; change pdf page order
204
CHAPTER 6
F
LOW
CONTROL
IN
SCRIPTS
statement list as long as a conditional test evaluates to true. Figure 6.5 shows the 
while
statement syntax.
When you execute a 
while
statement, PowerShell evaluates the 
<pipeline>
sec-
tion  of the statement before entering the 
<statementList>
section. The output 
from the pipeline is then converted to either true or false, following the rules for the 
Boolean interpretation of values described in chapter 3. As long as this result converts 
to true, PowerShell reruns the 
<statementList>
section, executing each statement 
in the list.
For example, the following 
while
statement displays the numbers 1 through 3:
$val = 0 
while($val -ne 3) 
{
$val++
write-host "The number is $val" 
}
In this example, the condition (
$val
isn’t equal to 3) is true while 
$val
is 0, 1, and 2. 
Each time through the loop, 
$val
is incremented by 1 using the unary 
++
increment 
operator (
$val++
). The last time through the loop, 
$val
is 3. When 
$val
equals 3, 
the condition statement evaluates to false and the loop exits.
To more conveniently enter this command at the PowerShell command prompt, 
you can simply enter it all on one line:
$val=0; while ($val -ne 3){$val++; write-host "The number is $val"}
Notice that the semicolon separates the first command that adds 1 to 
$val
from the 
second command, which writes the value of 
$val
to the console.
You can accomplish all the basic iterative patterns just using the 
while
loop, but 
PowerShell provides several other looping statements for common cases. Let’s look at 
those next.
6.2.2
The do-while loop
The other 
while
loop variant in PowerShell is the 
do-while
loop. This is a bottom-
tested variant of the 
while
loop. In other words, it always executes the statement list
while ( <pipelineToTest> ) { <statementList> }
while keyword
Pipeline to test, enclosed
in parentheses
Statement list, executed while
pipeline to test evaluates to true
Braces marking beginning and
end of statement block
Figure 6.5 The PowerShell 
while
loop statement syntax
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
page will teach you to rearrange and readjust amount of robust PPT slides/pages editing methods and powerful & profession imaging controls, PDF document, image
reorder pages in pdf preview; how to move pages in pdf converter professional
Process Images in Web Image Viewer | Online Tutorials
used document types are supported, including PDF, multi-page easy to process image and file pages with the deleting a thumbnail, and you can rearrange the file
how to move pages in pdf acrobat; how to change page order in pdf document
L
OOPING
STATEMENTS
205
at least once before checking the condition. The syntax of the 
do-while
loop is 
shown in figure 6.6.
The 
do-while
loop is effectively equivalent to 
<statementList> 
while ( <pipeLine> ) 
{
<statementList> 
}
where the two statement lists are identical. The final variation of the 
while
loop is 
the 
do/until
statement. It’s identical to the 
do/while
loop except that the sense of 
the test is inverted and the statement will loop until the condition is true instead of 
while it is true, as shown in this example:
PS (1) > $i=0
PS (2) > do { $i } until  ($i++ -gt 3) 
4
In this case, the statement loops until 
$i
is greater than 3. 
Having covered the two variations of the 
while
loop, we’ll look at the 
for
and 
foreach
loops next.
6.2.3
The for loop
The 
for
loop is the basic counting loop in PowerShell. It’s typically used to step 
through a collection of objects. It’s not used as often in PowerShell as in other lan-
guages because there are usually better ways for processing a collection, as you’ll see 
with the 
foreach
statement in the next section. But the 
for
loop is useful when you 
need to know explicitly which element in the collection you’re working with. Figure
6.7 shows the 
for
loop syntax.
Notice that the three pipelines in the parentheses are just general pipelines. Con-
ventionally, the initialization pipeline initializes the loop counter variable, the test
do { <statementList> } while ( <pipelineToTest> )
do keyword
Pipeline to test, enclosed
in parentheses
Statement list, executed while
pipeline to test evaluates to true
Braces marking beginning and
end of statement block
while keyword
Figure 6.6 The PowerShell 
do-while
loop statement syntax
206
CHAPTER 6
F
LOW
CONTROL
IN
SCRIPTS
pipeline tests this variable against some condition, and the increment pipeline incre-
ments the loop counter. The canonical example is
PS (1) > for ($i=0; $i -lt 5; $i++) { $i } 
PS (2) >
But because these are arbitrary pipelines, they can do anything. (Note that if initial-
ization and increment pipelines produce output, it’s simply discarded by the inter-
preter.) Here’s an example where the condition test is used to generate a side effect 
that’s then used in the statement list body:
PS (2) > for ($i=0; $($y = $i*2; $i -lt 5); $i++) { $y } 
PS (3) >
In this example, the pipeline to be tested is a subexpression that first sets 
$y
to be 
twice the current value of 
$i
and then compares 
$i
to 5. In the loop body, you use 
the value in 
$y
to emit the current loop counter times 2. A more practical example 
would be initializing two values in the initialization pipeline:
PS (3) > for ($($result=@(); $i=0); $i -lt 5; $i++) {$result += $i } 
PS (4) > "$result" 
0 1 2 3 4
Here you use a subexpression in the initialization pipeline to set 
$result
to the 
empty array and the counter variable 
$i
to 0. Then the loop counts up to 5, adding 
each value to the result array.
NOTE
It’s a little funny to talk about the initialization and increment 
pipelines. You usually think of pipelines as producing some output. In 
the 
for 
statement, the output from these pipelines is discarded and 
the side effects of their execution are the interesting parts.
for ( <pipeline> ; <pipeline> ; <pipeline> ) { <statementList> }
for keyword
Initialization pipeline
Statement list, executed while
pipeline to test evaluates to true
Braces marking beginning and
end of statement block
Pipeline to test
Increment pipeline
Figure 6.7 The PowerShell 
for
loop statement syntax
L
OOPING
STATEMENTS
207
Now let’s look at one more example using the 
for
loop. Here you’ll use it to sum up 
the number of handles used by the 
svchost
processes. First you’ll get a list of these 
processes:
PS (1) > $svchosts = get-process svchost
You’ll loop through this list and add the handle count for the process to 
$total
PS (2) > for ($($total=0;$i=0); $i -lt $svchosts.count; $i++) 
>> {$total+=$svchosts[$i].handles} 
>>
and then print out the total:
PS (3) > $total 
3457
So using the 
for
loop is straightforward, but it’s somewhat annoying to have to manage 
the loop counter. Wouldn’t it be nice if you could just let the loop counter count take 
care of itself? That’s exactly what the 
foreach
loop does for you, so let’s move on. 
6.2.4
The foreach loop
Collections are important in any shell (or programming) environment. The whole 
point of using a scripting language for automation is so that you can operate on more 
than one object at a time. As you’ve seen in chapters 3 and 4, PowerShell provides 
many ways of operating on collections. Perhaps the most straightforward of these 
mechanisms is the 
foreach
loop. 
NOTE
Astute readers will remember that we mentioned a 
foreach 
cmdlet (which is an alias for the 
ForEach-Object 
cmdlet) as well as 
the 
foreach
statement at the beginning of the chapter. To reiterate, 
when the word “foreach” is used at the beginning of a statement, it’s 
recognized as the 
foreach
keyword. When it appears in the middle of 
a pipeline, it’s treated as the name of a command.
This statement is syntactically identical to the 
C
foreach
loop with the exception 
that you don’t have to declare the type of the loop variable (in fact, you can’t do this). 
Figure 6.8 shows you the syntax for the 
foreach
statement.
foreach ( <variable> in <pipeline> ) { <statementList> }
foreach keyword
Loop variable
Statement list, executed once for each element
produced by pipeline to loop over
Braces marking beginning and
end of statement block
in keyword
Pipeline to loop over
Figure 6.8 The PowerShell 
foreach
loop statement syntax
208
CHAPTER 6
F
LOW
CONTROL
IN
SCRIPTS
Here’s an example. This example loops over all the text files in the current directory, 
calculating the total size of all the files:
$l = 0; foreach ($f in dir *.txt) { $l += $f.length }
First you set the variable that will hold the total length to 0. Then, in the 
foreach 
loop, you use the 
dir
command to get a list of the text files in the current directory 
(that is, files with the .txt
extension). The 
foreach
statement assigns elements from 
this list one at a time to the loop variable 
$f
and then executes the statement list with 
this variable set. At the end of the statement, 
$f
will retain the last value that was 
assigned to it, which is the last value in the list. Compare this example to the 
for 
loop example at the end of the previous section. Because you don’t have to manually 
deal with the loop counter and explicit indexing, this example is significantly simpler.
NOTE
In 
C
#, the 
foreach
loop variable is local to the body of the 
loop and is undefined outside of the loop. This isn’t the case in Power-
Shell; the loop variable is simply another variable in the current scope. 
After the loop has finished executing, the variable is still visible and 
accessible outside the loop and will be set to the last element in the list. 
If you do want to have a locally scoped variable, you can do this with 
scriptblocks, which are discussed in detail in chapter 8.
Now let’s use a variation of a previous example. Say you want to find out the number 
of text files in the current directory and the total length of those files. First you’ll ini-
tialize two variables: 
$c
to hold the count of the files and 
$l
to hold the total length:
PS (1) > $c=0
PS (2) > $l=0
Next run the 
foreach
statement:
PS (3) > foreach ($f in dir *.txt) {$c += 1; $l += $f.length }
Finally display the results accumulated in the variables:
PS (4) > $c 
PS (5) > $l 
105 
PS (6) >
Let’s look at the actual 
foreach
statement in detail now. The 
<pipeline>
part in 
this example is
dir *.txt
This produces a collection of 
System.IO.FileInfo
objects representing the files in 
the current directory. The 
foreach
statement loops over this collection, binding each 
object to the variable 
$f
and then executing the loop body.
L
OOPING
STATEMENTS
209
Evaluation order in the foreach loop
It’s important to note that this statement doesn’t stream the results of the pipeline. 
The pipeline to loop over is run to completion and only then does the loop body 
begin executing. Let’s  take  a second  to  compare  this  behavior with the  way the 
ForEach-Object
cmdlet works. Using the 
ForEach-Object
cmdlet, this statement 
would look like
dir *.txt | foreach-object { $c += 1; $l += $_.length }
In the case of the 
ForEach-Object
, the statement body is executed as soon as each 
object is produced. In the 
foreach
statement, all the objects are collected before the 
loop body begins to execute. This has two implications. 
First, because in the 
foreach
statement case all the objects are gathered at once, 
you need to have enough memory to hold all these objects. In the 
ForEach-Object 
case, only one object is read at a time, so less storage is required. From this, you’d 
think  that 
ForEach-Object
should always be preferred. In the bulk-read case, 
though, there are some optimizations that the 
foreach
statement does that allow it 
to perform significantly faster than the 
ForEach-Object
cmdlet. The result is a clas-
sic speed versus space trade-off. In practice, you rarely need to consider these issues, 
so use whichever seems most appropriate to the solution at hand.
NOTE
The 
ForEach-Object
cmdlet is covered later on in this chap-
ter. For Ruby language fans, 
ForEach-Object
is effectively equivalent 
to the 
.map()
operator.
The second difference is that, in the 
ForEach-Object
case, the execution of the 
pipeline  element  generating  the  object  is  interleaved  with  the  execution  of  the 
ForEach-Object
cmdlet. In other words, the command generates one object at a 
time and then passes it to 
foreach
for processing before generating the next element. 
This means that the statement list can affect how subsequent pipeline input objects 
are generated.
NOTE
Unlike traditional shells where each command is run in a sepa-
rate process and  can therefore run at the same time,  in PowerShell 
they’re alternating—the command on the left side runs and produces 
an object, and then the command on the right side runs. 
Using the $foreach loop enumerator in the foreach statement 
Executing the 
foreach
statement also defines a special variable for the duration of 
the loop. This is the 
$foreach
variable, and it’s bound to the loop enumerator. (An 
enumerator is a .
NET
object that captures  the  current position in a sequence of 
objects. The 
foreach
statement keeps track of where it is in the collection through
Documents you may be interested
Documents you may be interested