190
CHAPTER 5
A
DVANCED
OPERATORS
AND
VARIABLES
Notice that this example specified the 
-Value
parameter. What happens if you don’t 
do that? 
PS (10) > get-variable srcHost | gm
TypeName: System.Management.Automation.PSVariable
Name         MemberType Definition 
----         ---------- ----------
Equals       Method     bool Equals(System.Object obj) 
GetHashCode  Method     int GetHashCode()
GetType      Method     type GetType()
IsValidValue Method     bool IsValidValue(System.Object ... 
ToString     Method     string ToString()
Attributes   Property   System.Collections.ObjectModel.C... 
Description  Property   System.String Description {get;s... 
Module       Property   System.Management.Automation.PSM... 
ModuleName   Property   System.String ModuleName {get;} 
Name         Property   System.String Name {get;}
Options      Property   System.Management.Automation.Sco... 
Value        Property   System.Object Value {get;set;} 
Visibility   Property   System.Management.Automation.Ses...
If a value  for 
-Variable
isn’t specified, 
Get-Variable
returns the 
PSVariable 
object that PowerShell uses to represent this object. You can see the 
Name
and 
Value 
properties on this object, but there are a lot of other properties as well. Let’s explore 
the 
Options
property. This property allows us to set options on the variable includ-
ing things like 
ReadOnly
and 
Constant
. The variables you’ve read from the 
CSV
file 
are still changeable:
PS (11) > $srcHost = "machine9" 
PS (12) > $srcHost 
machine9
But, if you’re using them to configure the environment, you may not want them to 
be. To address this, you can set the 
ReadOnly
option using 
Set-Variable
and the 
-Option
parameter:
PS (13) > set-variable -option readonly srcHost machine1 
PS (14) > $srcHost = "machine4"
Cannot overwrite variable srcHost because it is read-only o 
r constant.
At line:1 char:9 
+ $srcHost <<<<  = "machine4"
+ CategoryInfo          : WriteError: (srcHost:String)
[], SessionStateUnauthorizedAccessException
+ FullyQualifiedErrorId : VariableNotWritable
Now when you try and change the value of this variable, you get an error. The vari-
able is unchanged:
Pdf reorder 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 in preview; how to rearrange pdf pages
Pdf reorder 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
how to rearrange pages in a pdf reader; how to rearrange pages in pdf using reader
W
ORKING
WITH
VARIABLES
191
PS (15) > get-variable -value srcHost
Name                           Value 
----                           -----
srcHost                        machine1
If you can’t change it, how about removing it? Try just the 
remove
command:
PS (16) > remove-variable srcHost 
Remove-Variable : Cannot remove variable srcHost because it
is constant or read-only. If the variable is read-only, tr 
y the operation again specifying the Force option.
At line:1 char:16 
+ remove-variable <<<<  srcHost
+ CategoryInfo          : WriteError: (srcHost:String)
[Remove-Variable], SessionStateUnauthorizedAccessExce
ption
+ FullyQualifiedErrorId : VariableNotRemovable,Microso
ft.PowerShell.Commands.RemoveVariableCommand
This failed with the expected error. But you can still force the removal of a read-only 
variable by using the 
-Force
parameter on 
Remove-Variable
:
PS (17) > remove-variable -force srcHost
When you specify 
-Force
, the variable is removed and there’s no error. If you don’t 
want the value to be changed, you can use the 
Constant
option:
PS (18) > set-variable -option constant srcHost machine1
When this option is specified, even using 
-Force
will fail:
PS (19) > remove-variable -force srcHost 
Remove-Variable : Cannot remove variable srcHost because it
is constant or read-only. If the variable is read-only, tr 
y the operation again specifying the Force option.
At line:1 char:16 
+ remove-variable <<<<  -force srcHost
+ CategoryInfo          : WriteError: (srcHost:String)
[Remove-Variable], SessionStateUnauthorizedAccessExce
ption
+ FullyQualifiedErrorId : VariableNotRemovable,Microso
ft.PowerShell.Commands.RemoveVariableCommand
And now for one last trick. You’ve looked at how to use the name of a variable to 
access it indirectly. You can bypass the name-lookup process and use the variable ref-
erence directly. Let’s see how this works.
Using PSVariable objects as references
To use a 
PSVariable
object as a reference, first you have to get one. Earlier you saw 
how to do this with 
Get-Variable
(or its alias 
gv
):
PS (21) > $ref = gv destHost
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
Reorder, Rearrange and Sort TIFF Document Pages in C#.NET Application. C# TIFF Page Sorting Overview. Reorder TIFF Pages in C#.NET Application.
how to reorder pdf pages in reader; move pages in pdf document
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
Sort and Reorder PowerPoint Slides Range with VB amount of robust PPT slides/pages editing methods powerful & profession imaging controls, PDF document, image
pdf reorder pages; move pages in pdf online
192
CHAPTER 5
A
DVANCED
OPERATORS
AND
VARIABLES
Now that you have a reference, you can use the reference to get the variable’s name
PS (22) > $ref.Name 
destHost
or its value:
PS (23) > $ref.Value 
machine2
Having the reference also allows you to set the variable’s value:
PS (24) > $ref.Value = "machine12"
When you check the variable using the language syntax, you see the change.
PS (25) > $destHost 
machine12
Variable names vs. variable values
Here’s a tip to keep in mind if you’re trying to do these tricks. You need to keep vari-
able name and variable value firmly separated in your thinking. If you don’t think 
about what you’re doing closely enough, trying to use 
$name
to get the value of the 
variable seems reasonable:
PS (26) > gv $srcPath 
Get-Variable : Cannot find a variable with name '@{Name=src 
Path; Value=c:\data\source\mailbox.pst}'.
At line:1 char:3 
+ gv <<<<  $srcPath
+ CategoryInfo          : ObjectNotFound: (@{Name=srcP
ath;...ce\mailbox.pst}:String) [Get-Variable], ItemNot
FoundException
+ FullyQualifiedErrorId : VariableNotFound,Microsoft.P
owerShell.Commands.GetVariableCommand
But it gives you a rather confusing error. This is because PowerShell resolved the 
token 
$srcPath
and passed its value to the cmdlet, not the name. Even quoting it but 
still having the 
$
sign in the string is wrong:
PS (27) > gv '$srcPath'
Get-Variable : Cannot find a variable with name '$srcPath'. 
At line:1 char:3 
+ gv <<<<  '$srcPath'
+ CategoryInfo          : ObjectNotFound: ($srcPath:St
ring) [Get-Variable], ItemNotFoundException
+ FullyQualifiedErrorId : VariableNotFound,Microsoft.P
owerShell.Commands.GetVariableCommand
This error seems bizarre because you know that there’s such a variable. The reason it 
fails is because 
$
isn’t part of the variable’s name. It’s part of a token in the PowerShell 
language indicating that whatever follows the 
$
is the name of a variable.
The correct way to do this is to use the variable name without the leading 
$
.
VB.NET TIFF: Modify TIFF File by Adding, Deleting & Sort TIFF
Users can use it to reorder TIFF pages in ''' &ltsummary> ''' Sort TIFF document pages in designed powerful & profession imaging controls, PDF document, image
how to reorder pages in pdf online; move pages in pdf reader
C# PDF Page Rotate Library: rotate PDF page permanently in C#.net
page, it is also featured with the functions to merge PDF files using C# .NET, add new PDF page, delete certain PDF page, reorder existing PDF pages and split
switch page order pdf; how to reorder pages in pdf preview
W
ORKING
WITH
VARIABLES
193
PS (28) > gv srcPath
Name                           Value 
----                           -----
srcPath                        @{Name=srcPath; Value=c:\...
Finally, here’s why all of this works the way it does. Define a variable 
$n
that has part 
of the path name:
PS (29) > $n = 'src'
Now combine that variable with another fragment using string expansion, and it 
works properly:
PS (30) > gv "${n}Path"
Name                           Value 
----                           -----
srcPath                        @{Name=srcPath; Value=c:\...
PS (31) >
This gives you a great deal of flexibility when dealing with variable names. It can be 
complex but any situation where you need to do this is, by definition, complex. Hav-
ing this facility doesn’t complicate normal day-to-day activities but does make some 
more sophisticated scenarios possible. Now let’s look at another set of potentially 
complex scenarios that can be solved by using variables in a special way.
5.8.4
Splatting a variable
The last topic that we’re going to touch on in this chapter is something called variable 
splatting, which was added to PowerShell in version 2. This is a term taken from the 
Ruby scripting language and affects how argument variables are passed to commands.
Normally, when you have a variable containing an array or hashtable and you use 
this variable as a command argument, its value is passed as a single argument. Splat-
ting turns each value in the collection into individual arguments. So, if you have an 
array with three elements in it, those elements will be passed as three individual argu-
ments. If you have a hashtable, each  name-value pair becomes a named parame-
ter–argument pair for the command. 
To do this is, when referencing the variable that you want to pass to the com-
mand, you use 
@
instead of 
$
as the prefix to the variable. Here’s an example to show 
how this works. First you need a command to work with—you’ll define a function 
(see chapter 7) that takes three arguments:
PS {1) > function s ($x, $y, $z) { "x=$x, y=$y, z=$z" }
This function uses string expansion to display the value of each of its parameters. 
Now create an array to pass into this command:
PS {2) > $list = 1,2,3
Read PDF in Web Image Viewer| Online Tutorials
from PDF documents; Extract images from PDF documents; Add, reorder pages in PDF files; Save and print PDF as you wish; More PDF Reading
rearrange pages in pdf reader; how to move pages around in pdf file
C# PDF: C# Code to Process PDF Document Page Using C#.NET PDF
just following attached links. C# PDF: Add, Delete, Reorder PDF Pages Using C#.NET, C# PDF: Merge or Split PDF Files Using C#.NET.
move pages in pdf acrobat; reorder pdf pages reader
194
CHAPTER 5
A
DVANCED
OPERATORS
AND
VARIABLES
The  variable 
$list
contains three integers. Pass this using the normal variable 
notation:
PS {3) > s $list 
x=1 2 3, y=, z=
From the output, you can see that all three values in the argument were assigned to 
the 
$x
parameter. The other two parameters didn’t get assigned anything. Next, splat 
the variable by calling the function with 
@list
instead of 
$list
:
PS {4) > s @list 
x=1, y=2, z=3
This time the output shows that each parameter was assigned one member of the 
array in the variable. What happens if there are more elements than there are vari-
ables? Let’s try it. First add some elements to your 
$list
variable:
PS {5) > $list += 5,6,7 
PS {6) > $list 
7
Now the variable contains seven elements. Pass this to the function:
PS {7) > s @list 
x=1, y=2, z=3
It appears that the last four arguments have vanished. In fact, what has happened is that 
they’re assigned to the special variable 
$args
. Let’s redefine the function to show this:
PS {8) > function s ($x, $y, $z) { "$x,$y,$z args=$args" }
Print out the three formal arguments 
$x
$
, and 
$z
along with the special 
$args
vari-
able. When you run the new function
PS {9) > s @list 
1,2,3 args=5 6 7
you see that the missing arguments have ended up in 
$args
. The most important use 
for splatting is for enabling one command to effectively call another. You’ll see how 
this can be used to wrap existing commands and either extend or restrict their behav-
ior in later chapters. (Variable parameters and how they’re bound is covered in much 
more detail in chapter 7.) 
Now that you understand how an array of values can be splatted, let’s look at how 
you work with named parameters. In the previous example, you could have used the 
explicit names of the parameters to pass things in instead of relying on position. For 
example, you can use the names to explicitly pass in values for 
-x
and 
-y
, in the 
reverse order
.NET Multipage TIFF SDK| Process Multipage TIFF Files
SDK, developers are easily to access, extract, swap, reorder, insert, mark up and delete pages in any multi upload to SharePoint and save to PDF documents.
reordering pages in pdf; change page order pdf reader
C# Word: How to Create Word Document Viewer in C#.NET Imaging
in C#.NET; Offer mature Word file page manipulation functions (add, delete & reorder pages) in document viewer; Rich options to add
pdf page order reverse; change pdf page order reader
W
ORKING
WITH
VARIABLES
195
PS {10) > s -y first -x second 
second,first, args=
and you see that 
second
is in the first (x) position and 
first
is in the second posi-
tion. How can you use splatting to do this? Well, parameters and their values are 
name-value pairs, and in PowerShell, the way to work with name-value pairs is with 
hashtables. Let’s try this out. First create a hashtable with the values you want:
PS {11) > $h = @{x='second'; y='first'}
Now splat the hashtable the same way you splatted the variable containing an array
PS {12) > s @h 
second,first, args=
and, as before, the 
x
parameter gets the value 
second
and the 
y
parameter gets the 
value 
first
. The next question you should have is, what happens if you also want to 
explicitly pass in 
-z
? Try it:
PS {13) > s -z third  @h 1 2 3 
second,first,third args=1 2 3
It works exactly the way you want. If you specify the parameter both in the hashtable 
and explicitly on the command line, you’ll get an error:
PS {14) > s -x boo  @h 1 2 3 
s : Cannot bind parameter because parameter 'x' is specifie 
d more than once. To provide multiple values to parameters 
that can accept multiple values, use the array syntax. For 
example, "-parameter value1,value2,value3".
At line:1 char:2 
+ s <<<<  -x boo  @h 1 2 3
+ CategoryInfo          : InvalidArgument: (:) [s], Pa
rameterBindingException
+ FullyQualifiedErrorId : ParameterAlreadyBound,s
Let’s look at a practical example using this feature. The 
Write-Host
cmdlet allows 
you to write strings to the screen specifying the foreground and background colors. 
This is great, but if you need to write a lot of strings or parameterize the colors that 
are used, repeatedly setting both parameters will get a bit tedious:
PS {16) > write-host -foreground black -background white Hi 
Hi
Specifying the parameters takes up more space than the string you want to write! 
Using splatting, instead of passing in both parameters all the time, you can set up a 
hashtable once and pass that around instead:
PS {17) > $colors = @{foreground="black";background="white"} 
PS {18) > write-host @colors "Hi there"
Hi there
196
CHAPTER 5
A
DVANCED
OPERATORS
AND
VARIABLES
This approach is more convenient and less error prone than having to explicitly pass 
both color parameters, making it an effective way to “style” your output using a single 
variable.
NOTE
By now I’m sure you’re wondering why this technique is it 
called splatting. Here’s the reasoning behind this term. Think of a rock 
hitting a car windshield. A rock is a solid object that remains intact 
after it bounces off your car. Next, think of a bug hitting the wind-
shield instead of a rock. Splat! The contents of the bug are distributed 
over the windshield instead of remaining as a single object. This is 
what splatting does to a variable argument. It distributes the members 
of the argument collection as individual arguments instead of remain-
ing a single intact argument. (The other rational behind this term is 
that, in Ruby, the operator is 
*
, which is what the aforementioned 
insect looks like post-impact. PowerShell can’t use 
*
because it would 
be confused with the wildcard character. Instead it uses 
@
because splat-
ting involves arrays and PowerShell uses 
@
for many array operations.) I 
submit that this is the most visceral mnemonic in the programming 
language field (at least that I’m aware of).
This is all we’re going to say about variables here. In chapter 7, we’ll return to vari-
ables and talk about how variables are defined in functions and how they’re scoped in 
the PowerShell language. We’ll also look at splatting again when we cover how com-
mands can call other commands.
5.9
S
UMMARY
In this chapter, we finished our coverage of PowerShell operators and expressions. We 
looked at how to build complex data structures in PowerShell and how to use the 
redirection operators  to  write output to files. We  covered  arrays,  properties, and 
methods. Finally, we explored the basics of PowerShell variable semantics and variable 
namespaces. Here are the important points to remember:
• The type operators allow you to write scripts that have polymorphic behavior. By 
using these operators to examine the types of objects, you can decide how to 
process different types of objects. You can also use the operators to dynamically 
convert from one type of object to another.
• The prefix and postfix operators 
++
and 
--
are a convenient way of increment-
ing and decrementing variables.
• The subexpression operator 
$( ... )
allows you to use arbitrary PowerShell 
script code anywhere that you can use a value expression. The array subexpres-
sion operator 
@(  ...  )
also guarantees that the result of an expression will 
always be an array.
S
UMMARY
197
• PowerShell arrays support both jagged arrays—that is, arrays that contain or ref-
erence other arrays and multidimensional  arrays. Array  slicing is  supported, 
both for one-dimensional and multidimensional arrays when retrieving values. 
It isn’t supported when assigning to an array index.
• Use the comma operator (
,
)to build arrays and complex nested data structures 
such as jagged arrays.
• Use the dot operator (
.
) for accessing instance members and the double-colon 
(
::
) operator for accessing static members. We looked at how to  indirectly 
invoke both properties and methods using these operators.
• The PowerShell redirection operators allow you to control where the output 
and error objects are written. They also allow you to easily discard these objects 
if so desired by redirecting to 
$null
. The redirection operators are just “syntac-
tic sugar” for the 
Out-File
cmdlet. Using the cmdlet directly allows you to 
control things such as what file encoding will be used when writing to a file.
• The format operator 
-f
can be used to perform complex formatting tasks when 
the  default  formatting  doesn’t  produce  the  desired  results.  The  formatting 
sequences are the same as the sequences used by the 
System.String.Format() 
method in the .
NET F
ramework.
• PowerShell  variable  namespaces  let  you  access  a  variety  of  Windows  “data 
stores,” including environment variables and the file system using the variable 
notation.
• It’s possible to use the variable cmdlets to set options on variables and do indi-
rect variable accesses using either the variable name or a 
PSVariable
object.
• PowerShell version 2 introduced a new variable notation called splatting that 
allows you to take collections of values, either arrays or hashtables, and distrib-
ute the members of these collections as individual arguments to a command.
198
C
H
A
P T E R   6
Flow control in scripts
6.1  The conditional statement   200
6.2  Looping statements  203
6.3  Labels, break, and continue  212
6.4  The switch statement  215
6.5  Flow control using cmdlets  223
6.6  Statements as values  231
6.7  A word about performance  233
6.8  Summary  234
I may not have gone where I intended to go, but I think I have ended up where 
I needed to be.
—Douglas Adams, The Long Dark Tea-Time of the Soul
Previous  chapters  showed  how  you  can  solve  surprisingly  complex  problems  in 
PowerShell using only commands and operators. You can select, sort, edit,you and 
present all manner of data by composing these elements into pipelines and expres-
sions. In fact, commands and operators were the only elements available in the earli-
est prototypes of PowerShell. Sooner or later, though, if you want to write significant 
programs or scripts, you must add custom looping or branch logic to your solution. 
This is what we’re going to cover in this chapter: PowerShell’s take on the traditional 
programming constructs that all languages possess.
The  PowerShell  flow-control  statements  and cmdlets  are  listed  in  figure 6.1, 
arranged in groups. 
We’ll go through each group in this chapter. As always, behavioral differences 
exist with the PowerShell flow-control statements that new users should be aware of.
199
The most obvious difference is that PowerShell typically allows the use of pipelines 
in places where other  programming  languages only  allow simple expressions. An 
interesting implication of this pipeline usage is that the PowerShell 
switch
state-
ment is both a looping construct and a conditional statement—which is why it gets 
its own group.
This is also the first time we’ve dealt with keywords in PowerShell. Keywords are 
part of the core PowerShell language. This means that, unlike cmdlets, keywords 
can’t be redefined or aliased. Keywords are also case insensitive so you can write 
foreach
ForEach
, or 
FOREACH
and they’ll all be accepted by the interpreter. (By 
convention, though, keywords in PowerShell scripts are usually written in  lower-
case.) Keywords are also context sensitive, which means that they’re only treated as 
keywords in a statement context—usually as the first word in a statement. This is 
important because it lets you have both a 
foreach
loop statement and a 
foreach 
filter cmdlet, as you’ll see later in this chapter. Let’s begin our discussion with the 
conditional statement.
break                  break <label>
continue               continue <label>
if ( <expr> ) { <statements> } 
if ( <expr> ) { <statements> } else { <statements> } 
if ( <expr> ) { <statements> } elseif ( <expr> ) { <statements> } else { <statements> }
Conditional statements
while ( <expr> ) { <statements> } 
do { <statements> } while ( <expr> ) 
do { <statements> } until ( <expr> ) 
for ( <expr> ; <expr> ; <expr> ) { <statements> }
foreach ( $var in <pipeline> ) { <statements> }
Loop statements
Break and continue statements
switch ( <expr> ) { <pattern1> { <statements> } <pattern2> { <statements> } }
switch ( <expr> ) { <pattern1> { <statements> } default { <statements> } }
The switch statement
Flow-control cmdlets
… | ForEach-Object <scriptBlock> 
… | ForEach-Object -Begin <scriptBlock> -Process <scriptBlock> -End <scriptBlock>
… | Where-Object <scriptBlock>
Figure 6.1 The PowerShell flow-control statements
Documents you may be interested
Documents you may be interested