110
C
H
A
P T E R   4
Operators and expressions
4.1  Arithmetic operators  112
4.2  The assignment operators  119
4.3  Comparison operators  124
4.4  Pattern matching and text 
manipulation  131
4.5  Logical and bitwise operators  148
4.6  Summary  150
Operators, Mr. Rico! Millions of them!
—Robert A. Heinlein, Starship Troopers (paraphrased)
So far, we’ve covered the basics, and we’ve covered the type system in considerable 
depth. Now let’s look at how you can combine all this stuff and get some real work 
done. As in any language, objects are combined with operators to produce expres-
sions. When these expressions are evaluated, the operators perform their operations 
on objects, giving you (hopefully) useful results. This chapter covers the set of basic 
operators in PowerShell and how they’re used in expressions. The operators we’re 
going to cover in this chapter are shown in figure 4.1.
As you can see, PowerShell has operators. Lots of operators—the full complement 
you’d expect in a conventional programming language and several more. In addition, 
PowerShell operators are typically more powerful than the corresponding operators in 
conventional languages such as 
C
or 
C
++. So, if you invest the time to learn what the 
PowerShell operators are and how they work, in a single line of code you’ll be able to 
accomplish tasks that would normally take a significant amount of programming. 
Pdf reorder pages online - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
reorder pages of pdf; reordering pdf pages
Pdf reorder pages online - 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
reorder pages in pdf preview; change page order pdf reader
111
Here’s an example of the kind of thing that can be done using just the PowerShell 
operators. Say we have a file, old.txt, with the following text in it:
Hello there.
My car is red.  Your car is blue. 
His car is orange and hers is gray. 
Bob's car is blue too.
Goodbye.
Our task is to copy this content to a new file, making certain changes. In the new file, 
the word “is” should be replaced with “was,” but only when it’s in front of the word 
“red” or “blue.” In most languages, this would require a fairly complex program. In 
PowerShell, it takes exactly one line. Here’s the “script”:
${c:old.txt} -replace 'is (red|blue)','was $1' > new.txt
It  uses  the 
-replace
operator along with output redirection and variable 
namespaces. (The 
-replace
operator is described later in this chapter.) Redirection 
and variable namespaces are features for working with files that are covered in chapter
5. After running this script, the content of new.txt looks like this:
Hello there.
My car was red.  Your car was blue. 
His car is orange and hers is gray. 
Bob's car was blue too.
Goodbye.
NOTE
For the impatient  reader, the  notation 
${c:old.txt}
says, 
“Return the contents of the file old.txt from the current working direc-
tory on the 
C
: drive.” In contrast, 
${c:\old.txt}
says, “Get the file 
old.txt from the root of the 
C
: drive.”
    -
    /     %
Arithmetic operators
    +=     -=     *=     /=     %=
Assignment operators
-eq   -ne   -gt   -ge   -lt   -le 
Comparison operators
-contains   -notcontains
Containment operators
-like  -notlike  -match  -notmatch
-replace   -split   -join
Pattern-matching and text operators
-and   -or   -not   -xor
-band   -bor   -bnot   -bxor
Logical and bitwise operators
Figure 4.1 The broad groups of operators we’ll cover in this chapter
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.
reverse page order pdf online; how to move pages in pdf acrobat
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
move pdf pages; change pdf page order reader
112
CHAPTER 4
O
PERATORS
AND
EXPRESSIONS
As you can see, only the second and fourth lines have been changed as desired. The 
phrases “is red” and “is blue” have been changed to “was red” and “was blue.” The “is 
orange” and “is gray” phrases weren’t changed. From this example, you can also see 
that it’s possible to do quite a bit of work just with the operators.
One of the characteristics that makes PowerShell operators powerful is the fact 
that they’re polymorphic. This simply means that they work on more than one type of 
object. Although this is generally true in other object-based languages, in those lan-
guages the type of the object defines the behavior of the operator. 
NOTE
If you’re a C# or Visual Basic user, here’s something you might 
want to know. In “conventional” .
NET
languages, the operator sym-
bols  are  mapped  to  a  specific  method  name  on  a  class  called 
op_<operatorName>
. For example, in 
C
#, the plus operator (
+
) maps 
to the method 
op_Addition()
. Although PowerShell is a .
NET
lan-
guage,  it  takes  a  different  approach  that’s  more  consistent  with 
dynamic scripting languages, as you’ll see in the following sections.
In PowerShell, the interpreter primarily defines the behavior of the operators, at least 
for common data types. Type-based polymorphic methods are only used as a backup. 
By common types, we mean strings, numbers, hashtables, and arrays. This allows 
PowerShell to provide more consistent behavior over this range of common objects 
and also to provide higher-level behaviors than are provided by the objects them-
selves, especially when dealing with collections. We’ll cover these special behaviors in 
the sections for each class of operator. (The following sections have many examples, 
but the best way to learn is to try the examples in PowerShell yourself.) Now let’s get 
going and start looking at the operators.
4.1
A
RITHMETIC
OPERATORS
First  we’ll  cover  the  basic  arithmetic 
operators shown in figure 4.2.
We  touched  on  the  polymorphic 
behavior  of  these  operators  briefly  in 
chapter 3, where we discussed the vari-
ous  type  conversions.  The  operators 
themselves  are  listed  with  examples  in 
table 4.1.
Table 4.1 The basic arithmetic operators in PowerShell
Operator Description
Example
Result
+
Add two values together.
2+4
6
"Hi " + "there" "Hi there"
1,2,3 + 4,5,6
1,2,3,4,5,6
+      -
*      /      %
Arithmetic operators
Figure 4.2 The arithmetic operators in 
PowerShell that will be covered in this 
section 
Read PDF in Web Image Viewer| Online Tutorials
"This online guide content is Out Dated! Extract images from PDF documents; Add, reorder pages in PDF files; Save and print PDF as you wish;
move pages in a pdf; how to reorder pdf pages
C# PDF: C# Code to Process PDF Document Page Using C#.NET PDF
C# PDF Page Processing: Sort PDF Pages - online C#.NET tutorial page for how to reorder, sort, reorganize or re-arrange PDF document files using C#.NET code.
move pages in pdf document; reordering pages in pdf document
A
RITHMETIC
OPERATORS
113
In terms of behavior, the most interesting operators are 
+
and 
*
. We’ll cover these 
operators in detail in the next two sections.
4.1.1
The addition operator
As mentioned earlier, PowerShell defines the behavior of the 
+
and 
*
operators for 
numbers, strings, arrays, and hashtables. Adding or multiplying two numbers pro-
duces a numeric result following the numeric widening rules. Adding two strings per-
forms string concatenation, resulting in a new string, and adding two arrays joins the 
two arrays (array concatenation), producing a new array. Adding two hashtables cre-
ates a new hashtable with combined elements. The interesting part occurs when you 
mix operand types. In this situation, the type of the left operand determines how the 
operation will proceed. We’ll look at how this works with addition first.
NOTE
The “left-hand” rule for arithmetic operators: the type of the 
left-hand operand determines the type of the overall operation. This is 
an important rule to remember.
If the left operand is a number, PowerShell will try to convert the right operand to a 
number. Here’s an example. In the following expression, the operand on the left is a 
number and the operand on the right is the string “123”:
PS (1) > 2 + "123" 
125
Because the operand on the left is a number, according to the conversion rule the 
operand “123” must be converted into a number. Once the conversion is complete, 
the  numeric addition operation proceeds and produces the  result  125, as shown. 
Conversely, in the next example, when a string is on the left side
PS (2) > "2" + 123 
2123
the operand on the right (the number 123) is converted to a string and appended to 
“2” to produce a new string, “2123”.
*
Multiply two values.
2 * 4
8
"a" * 3
"aaa"
1,2 * 2
1,2,1,2
-
Subtract one value from another.
6-2
4
/
Divide two values.
6/2
3
7/4
1.75
%
Return the remainder from a division operation. 7%4
3
Table 4.1 The basic arithmetic operators in PowerShell (continued)
Operator Description
Example
Result
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
pdf reorder pages; rearrange pages in pdf online
C# PDF Page Rotate Library: rotate PDF page permanently in C#.net
Online C# class source codes enable the ability to rotate single NET, add new PDF page, delete certain PDF page, reorder existing PDF pages and split
how to move pages around in a pdf document; reorder pdf pages
114
CHAPTER 4
O
PERATORS
AND
EXPRESSIONS
If the right operand can’t be converted into the type of the left operand, then a 
type-conversion error will be raised:
PS (3) > 2 + "abc"
Cannot convert "abc" to "System.Int32". Error: "Input string was not
in a correct format." 
At line:1 char:4 
+ 2 +  <<<< "abc"
Because “abc” can’t be converted into a number, you’ll receive a type-conversion error. 
Now if this had been done using the hex notation as discussed in section 3.3.2, every-
thing would be fine:
PS (4) > 2 + "0xabc" 
2750
Because “a”, “b”, and “c” are valid hex digits, the string “0xabc” converts into the 
number 2748 and is then added to 2, yielding 2750.
The next PowerShell-defined polymorphic behavior for 
+
involves arrays or col-
lections. If the operand on the left is an array or collection, the operand on the right 
will be appended to that collection. If the right operand is a scalar value, it will be 
added to the array as is. If it’s already an array (or any type of enumerable collection), 
it will be appended to the collection.
At this point, it’s probably a good idea to reiterate how array catenation is done in 
PowerShell. Because the underlying .
NET
array objects are of fixed size (as discussed in 
chapter 3), catenation is accomplished by creating a new array of type 
[object[]] 
and copying the elements from the operands into this new array. In the process of cre-
ating the new array, any type constraint on the original arrays will be lost. For example, 
if the left operand is 
[int[]]
—that is, an array of type 
[int]
—and you add a non-
numeric string to it, a new array will be created that will be of type 
[object[]]
, which 
can hold any type of object. Let’s look at an example. First create an integer array:
PS (1) > $a = [int[]] (1,2,3,4) 
PS (2) > $a.GetType().FullName 
System.Int32[]
Now let’s do some assignments. First assign an integer:
PS (3) > $a[0] = 10
This works without error. Next try it with a string that can be converted into an inte-
ger. Use the hex string mentioned earlier:
PS (4) > $a[0] = "0xabc"
This also works fine. Finally, try assigning a non-numeric string to the array element:
PS (5) > $a[0] = "hello"
Array assignment to [0] failed: Cannot convert "hello" to 
"System.Int32". Error: "Input string was not in a correct format.". 
At line:1 char:4 
+ $a[0 <<<< ] = "hello"
C# Word: How to Create Word Document Viewer in C#.NET Imaging
Offer mature Word file page manipulation functions (add, delete & reorder pages) in document viewer; (Directly see online document viewer demo here.).
how to move pages in pdf reader; change pdf page order
VB.NET TIFF: VB.NET Sample Code to Process & Manage TIFF Page
certain TIFF page, and sort & reorder TIFF pages in Process TIFF Pages Independently in VB.NET Code. powerful & profession imaging controls, PDF document, image
move pages in pdf; rearrange pages in pdf document
A
RITHMETIC
OPERATORS
115
This fails, as you might expect. An array of type 
[int[]]
can only hold integers. 
Because 
"hello"
can’t be converted into an integer, you get the type-conversion error 
shown. So far, so good. Now let’s do an array concatenation:
PS (6) > $a = $a + "hello"
And now try the assignment that failed previously:
PS (7) > $a[0] = "hello" 
PS (8) > $a 
hello 
hello
This time the assignment succeeds without error. What happened here? Let’s look at 
the type of the array:
PS (9) > $a.GetType().FullName 
System.Object[]
When the new, larger array was created to hold the combined elements, it was created 
as type 
[object[]]
, which isn’t type constrained. It can hold any type of object, so 
the assignment proceeded without error.
Finally, let’s see how addition works with hashtables. Similar to arrays, addition of 
hashtables creates a new hashtable and copies the elements of the original tables into 
the new one. The left elements are copied first; then the elements from the right 
operand are copied. (This only works if both operands are hashtables.) If any colli-
sions take place—that is, if the keys of any of the elements in the right operand match 
the keys of any element in the left operand—then an error will occur saying that the 
key already exists in the hashtable. (This was an implementation decision; the Power-
Shell team could’ve had the new element overwrite the old one, but the consensus 
was that generating an error message is usually the better thing to do.)
PS (1) > $left=@{a=1;b=2;c=3} 
PS (2) > $right=@{d=4;e=5}
PS (3) > $new = $left + $right 
PS (4) > $new
Key                            Value 
---                            -----
                             4 
                             1 
                             2 
                             5 
                             3
The new hashtable is of type 
System.Collections.Hashtable
:
PS (5) > $new.GetType().FullName 
System.Collections.Hashtable
116
CHAPTER 4
O
PERATORS
AND
EXPRESSIONS
The table is created in such a way that the strings that are used as keys are compared 
in a case-insensitive way. 
This completes our discussion of the behavior of the addition operator. We cov-
ered how it works with numbers, strings, hashtables, and arrays. Now that we’ve fin-
ished with addition, let’s move on to the multiplication operator.
4.1.2
The multiplication operator
As with addition, PowerShell defines multiplication behavior for numbers, strings, 
and arrays. (We don’t do anything special for hashtables for multiplication.) Multiply-
ing numbers works as expected and follows the widening rules discussed in chapter 3. 
In fact, the only legal right-hand operand for multiplication is a number. If the oper-
and on the left is a string, then that string is repeated the number of times specified in 
the right operand. Let’s try this out. Multiply the string “abc” by 1, 2, and then 3:
PS (1) > "abc" * 1 
abc 
PS (2) > "abc" * 2 
abcabc 
PS (3) > "abc" * 3 
abcabcabc
The results are “abc”, “abcabc”, and “abcabcabc”, respectively. What about multiply-
ing by 0?
PS (4) > "abc" * 0 
PS (5) >
The result appears to be nothing—but which “nothing”—spaces, empty string, or 
null? The way things are displayed, you can’t tell by looking. Here’s how to check. 
First check the type of the result:
PS (5) > ("abc" * 0).GetType().FullName 
System.String
You see that it’s a string, not 
$null
. But it could still be spaces, so you need to check 
the length:
PS (6) > ("abc" * 0).Length 
0
And, because the length is 0, you can tell that it is in fact an empty string.
Now let’s look at how multiplication works with arrays. Because multiplication 
applied  to  a  string  repeats  the  string,  logically  you’d  expect  that  multiplication 
applied to an array should repeat the array, which is exactly what it does. Let’s look at 
some examples of this. First create an array with three elements:
PS (1) > $a=1,2,3 
PS (2) > $a.Length 
3
A
RITHMETIC
OPERATORS
117
Now multiply it by 2:
PS (3) > $a = $a * 2 
PS (4) > $a.Length 
6
The length of the new array is 6. Looking at the contents of the array (using variable 
expansion in strings to save space), you see that it’s “1 2 3 1 2 3”—the original array 
doubled. 
PS (5) > "$a" 
1 2 3 1 2 3
Multiply the new array by 3:
PS (6) > $a = $a * 3
And check that the length is now 18:
PS (7) > $a.Length 
18
It is, so looking at the contents
PS (8) > "$a" 
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3
you see that it is six repetitions of the original three elements.
As with addition, first a new larger array is created during multiplication, and 
then the component elements are copied into it. This has the same issue that addition 
had, where the new array is created without type constraints. Even if the original 
array could only hold numbers, the new array can hold any type of object.
4.1.3
Subtraction, division, and the modulus operator
Addition and multiplication are the most interesting of the arithmetic operators in 
terms of polymorphic behavior, but let’s go over the remaining operators. Subtraction, 
division, and the modulus (
%
) operators are only defined for numbers by PowerShell. 
(Modulus returns the remainder from a division operation.) Again, as with all numeric 
computations, the widening rules for numbers are obeyed. For the basic scalar types 
(such as strings and numbers), these operations are only defined for numbers, so if 
either operand is a number (not just the left-hand operand), an attempt will be made 
to convert the other operand into a number as well, as shown here:
PS (1) > "123" / 4
30.75 
PS (2) > 123 / "4"
30.75 
PS (3) >
In the first example, the string “123” is converted into a number. In the second exam-
ple, the string “4” will be converted into a number.
118
CHAPTER 4
O
PERATORS
AND
EXPRESSIONS
NOTE
Here’s an important characteristic about how division works in 
PowerShell that you should keep in mind. Integer division underflows 
into floating point (technically 
System.Double
). This means that 5 
divided by 4 in PowerShell results in 1.25 instead of 1, as it would in C#. 
If you want to round the decimal part to the nearest integer, simply cast 
the result into 
[int]
. You also need to be aware that PowerShell uses 
what’s called “Banker’s rounding” when converting floating point num-
bers into integers. Banker’s rounding rounds .5 up sometimes and down 
sometimes. The convention is to round to the nearest even number, so 
that both 1.5 and 2.5 round to 2, and 3.5 and 4.5 both round to 4. 
If neither operand is a number, the operation is undefined and you’ll get an error:
PS (3) > "123" / "4"
Method invocation failed because [System.String] doesn't contain 
a method named 'op_Division'.
At line:1 char:8 
+ "123" /  <<<< "4"
PS (4) >
Take note of this particular error message, though. PowerShell has no built-in defini-
tion for this operation, so as a last step it looks to see whether the type of the left 
operand defines a method for performing the operation. In fact, PowerShell looks for 
the 
op_<operation>
methods on the left operand if the operation isn’t one of those 
defined by PowerShell itself. This allows the operators to work on types such as 
Sys-
tem.Datetime
(the .
NET
representation of dates) even though there’s no special sup-
port for these types in PowerShell. 
Here’s an example. Suppose you want to find the total number of days between 
January 1, 2006, and February 1, 2006. You can create objects representing these 
dates by casting strings into 
DateTime
objects. Once you have these objects, you can 
convert them: 
PS (1) > ([DateTime] "2006-2-1" - [DateTime]"2006-1-1").TotalDays 
31
For those of you with children,  here’s a more useful example. Jeffrey Snover, the 
architect of PowerShell, tells a story about his daughter:
My daughter loves Christmas. She often asks me, “How long is it ’til 
Christmas?” The problem with that is that I’m one of those people who 
can barely remember what year it is, much less the date. Well, it’s one 
thing to be a flawed person and it’s another thing to disappoint your 
daughter. PowerShell to the rescue!
Here’s a little date math routine I wrote to help me out:
function tillXmas () 
{
$now = [DateTime]::Now
[DateTime]( [string] $now.Year + "-12-25") - $Now 
}
T
HE
ASSIGNMENT
OPERATORS
119
PS> tillxmas
Days              : 321 
Hours             : 18 
Minutes           : 8 
Seconds           : 26 
Milliseconds      : 171 
Ticks             : 277997061718750 
TotalDays         : 321.755858470775 
TotalHours        : 7722.14060329861 
TotalMinutes      : 463328.436197917 
TotalSeconds      : 27799706.171875 
TotalMilliseconds : 27799706171.875
Thanks to PowerShell, I can tell my daughter how many seconds to go 
until Christmas! Now if I can only get her to stop asking me in the car.
To take a look at the operator methods defined for 
System.DateTime
, you can use 
the 
GetMembers()
method. Here’s a partial listing of the operator methods defined. 
This example uses the PowerShell 
Select-String
cmdlet to limit what’s displayed 
to only those methods whose names contain the string “op_”:
PS (5) > [DateTime].GetMembers()| foreach{"$_"}| Select-String op_ 
System.DateTime op_Addition(System.DateTime, System.TimeSpan) 
System.DateTime op_Subtraction(System.DateTime, System.TimeSpan) 
System.TimeSpan op_Subtraction(System.DateTime, System.DateTime)
As you can see, not all the arithmetic operator methods are defined. In fact, no meth-
ods are defined for any operations other than addition and subtraction. If you try to 
divide a 
DateTime
object by a number, you’ll get the same error you saw when you 
tried to divide two strings:
PS (4) > [DateTime] "1/1/2006" / 22 
Method invocation failed because [System.DateTime] doesn't contain 
a method named 'op_Division'.
At line:1 char:24 
+ [DateTime] "1/1/2006" /  <<<< 22 
PS (5) >
The error occurred because PowerShell was looking for an 
op_Division()
on the 
object on the left. It didn’t find one, and therefore the operation failed.
Okay, now that you know all about arithmetic operators and operations in Power-
Shell, you need to have a way to save the results of these operations. Variable assign-
ment is the answer, so we’ll look at assignment and the assignment operators next.
4.2
T
HE
ASSIGNMENT
OPERATORS
In this section we’ll cover the assignment 
operators, which are shown in figure 4.3 
and listed with examples in table 4.2.
As  you  can  see,  along  with  simple 
assignment,  PowerShell  supports  the 
compound operators that are found in
=     +=     -=     *=     /=     %=
Assignment operators
Figure 4.3 The PowerShell assignment 
operators 
Documents you may be interested
Documents you may be interested