c# pdf viewer free : How to change page order in pdf acrobat application control utility azure web page wpf visual studio Windows%20Powershell%20in%20Action%202nd%20Edition15-part1467

120
CHAPTER 4
O
PERATORS
AND
EXPRESSIONS
C
-based languages. These compound operators retrieve, update, and reassign a vari-
able’s value all in one step. The result is a much more concise notation for expressing 
this type of operation.
In table 4.2, for each of the compound assignment operators, the third column 
shows the equivalent decomposed operation.
Of course, the arithmetic parts of the compound arithmetic/assignment operators 
follow all the rules for the arithmetic operators described in the previous section. The 
formal syntax for an assignment expression looks like this:
<lvalueList> <assignmentOperator> <pipeline> 
<lvalueList> := <lvalue> [ , <lvalue> ] * 
<lvalue> := <variable> | <propertyReference> | <arrayReference>
One  interesting  thing to  note  from this  syntax  is that  multiple  assignments  are 
allowed. For example, the expression
$a,$b,$c = 1,2,3,4
is a perfectly legal statement. It says, “Assign 1 to $a, assign 2 to $b, and assign the 
remaining elements 3 and 4 of the list to $c.” Multiple assignments can be used to 
greatly simplify certain types of operations, as you’ll see in the next section.
4.2.1
Multiple assignments
Multiple assignment works only with the basic assignment operator. You can’t use it 
with any of the compound  operators. It can, however, be used with any type of 
assignable expression such as an array element or property reference. Here’s a quick 
example where multiple assignment is particularly useful. The canonical pattern for 
swapping two variables in conventional languages is
$temp = $a 
$a = $b 
$b = $temp
Table 4.2 PowerShell assignment operators
Operator
Example
Equivalent
Description
=
$a= 3
Sets the variable to the specified value
+=
$a += 2
$a = $a + 2
Performs the addition operation in the existing value, 
and then assigns the result back to the variable
-=
$a -= 13
$a = $a – 13 Performs the subtraction operation in the existing 
value, and then assigns the result back to the variable
*=
$a *= 3
$a = $a * 3
Multiplies the value of a variable by the specified value 
or appends to the existing value
/=
$a /= 3
$a = $a / 3
Divides the value of a variable by the specified value
%=
$a %= 3
$a = $a % 3
Divides the value of a variable by the specified value 
and assigns the remainder (modulus) to the variable
How to change page order in pdf acrobat - 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 pages in pdf document; move pages in a pdf file
How to change page order in pdf acrobat - 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
pdf rearrange pages online; change page order in pdf file
T
HE
ASSIGNMENT
OPERATORS
121
This takes three lines of code and requires you to use a temporary variable. Here’s 
how to do it using multiple assignments in PowerShell:
$a,$b = $b,$a
It’s simple and clean—only one line of code with no temporary variables to worry 
about. Here’s a more interesting example. The Fibonacci sequence is a sequence of 
numbers where each element is defined as the sum of the previous two numbers in 
the sequence. It looks like this:
1 1 2 3 5 8 13 21 …
NOTE
The Fibonacci sequence is an oddly popular bit of mathematics. 
It shows up in books, movies, and seashells. In the West, it was first studied 
by Leonardo of Pisa, a.k.a. Fibonacci. He used this sequence to describe 
how rabbits multiply. Rabbits aren’t good at math, so it wasn’t very accu-
rate. The sequence also describes the progression of the spiral found in 
some shells. Mollusks are better at math than rabbits, apparently.
Here’s how to generate this sequence in PowerShell using multiple assignments:
PS (53) > $c=$p=1; 1; while ($c -lt 100) { $c; $c,$p = ($c+$p),$c } 
13 
21 
34 
55 
89
This example begins by initializing the two variables 
$c
(current) and 
$p
(previous) 
to 1. Then it loops while 
$c
is less than 100. 
$c
contains the current value in the 
sequence, so that value is emitted. Next comes the double assignment, where 
$c 
becomes the next element in the sequence and 
$p
becomes the current (now previ-
ous) value in the sequence. So far, you’ve seen that using multiple assignments can 
simplify basic operations such as swapping values. But when combined with some of 
PowerShell’s other features, it lets you do much more interesting things than that. 
You’ll see this in the next section.
4.2.2
Multiple assignments with type qualifiers
This is all interesting, but let’s look at a more practical example. Say you’re given a 
text file containing some data that you want to parse into a form you can work with. 
First let’s look at the data file:
quiet 0 25 
normal 26 50
.NET PDF Document Viewing, Annotation, Conversion & Processing
Convert image files to PDF. File & Page Process. Re-order, rotate PDF pages. PDF Read. Print. Support for all the print modes in Acrobat PDF.
pdf change page order acrobat; how to rearrange pdf pages reader
VB.NET PDF: How to Create Watermark on PDF Document within
create a watermark to PDF file in order to help or image (such as business's logo) on any desired PDF page. And with our PDF Watermark Creator, users need no
how to rearrange pages in pdf using reader; how to move pages in pdf files
122
CHAPTER 4
O
PERATORS
AND
EXPRESSIONS
loud 51 75 
noisy 75 100
This file contains a set of sound-level descriptions. The format is a string describing 
the level, followed by two numbers describing the upper and lower bounds for these 
levels out of a possible 100. You want to read this information into a data structure so 
you can use it to categorize a list of sounds later on. Here’s the fragment of PowerShell 
code needed to do this:
PS (2) > $data = get-content data.txt | foreach { 
>>     $e=@{} 
>>     $e.level, [int] $e.lower, [int] $e.upper = -split $_ 
>>     $e 
>> } 
>>
You start by using the 
Get-Content
cmdlet to write the data into a pipeline. Each line 
of the file is sent to the 
ForEach-Object
cmdlet to be processed. The first thing you 
do in the body of the 
foreach
cmdlet is initialize a hashtable in 
$e
to hold the result. 
You take each line stored in the 
$_
variable and apply the 
-split
operator to it. This 
splits the string into an array at each space character in the string. (The 
-split
oper-
ator is covered in detail later in this chapter.)  For example, the string
"quiet 0 25" 
becomes an array of three strings:
"quiet","0","25"
Then  you  assign  the  split  string  to  three  elements  of  the  hashtable: 
$e.level
$e.lower
, and 
$e.upper
. But there’s one more thing you want to do. The array 
being assigned is all strings. For the upper and lower bounds, you want numbers, not 
strings. To do this, add a cast before the assignable element. This causes the value 
being assigned to first be converted to the target type. The end result is that the upper 
and lower fields in the hashtable are assigned numbers instead of strings. Finally, note 
that the result of the pipeline is being assigned to the variable 
$data
, so you can use it 
later on.
Let’s look at the result of this execution. Because there were four lines in the file, 
there should be four elements in the target array:
PS (3) > $data.Length 
4
You see that there are. Now let’s see if the value stored in the first element of the array 
is what you expect: it should be the “quiet” level.
PS (4) > $data[0]
Key                            Value 
---                            -----
upper                          25 
level                          quiet 
lower                          0
GIF to PDF Converter | Convert GIF to PDF, Convert PDF to GIF
as easy as printing; Support both single-page and batch Drop image to process GIF to PDF image conversion; Provide filter option to change brightness, color and
move pages within pdf; change pdf page order online
JPEG to PDF Converter | Convert JPEG to PDF, Convert PDF to JPEG
It can be used standalone. JPEG to PDF Converter is able to convert image files to PDF directly without the software Adobe Acrobat Reader for conversion.
rearrange pages in pdf reader; how to move pages in pdf converter professional
T
HE
ASSIGNMENT
OPERATORS
123
It is. Finally, let’s verify that the types were properly converted:
PS (5) > $data[0].level 
quiet 
PS (6) > $data[0].lower 
PS (7) > $data[0].upper 
25 
PS (8) > $data[0].level.GetType().FullName 
System.String 
PS (9) > $data[0].lower.GetType().FullName 
System.Int32 
PS (10) > $data[0].upper.GetType().FullName 
System.Int32
Again you use the 
GetType()
method to look at the types, and you can see that the 
level description  field is a  string and  that  the two bounds fields  are  integers,  as 
expected. 
In this last example, you’ve seen how array assignment can be used to perform 
sophisticated tasks in only a few lines of code. By now, you should have a good sense 
of the utility of assignments in processing data in PowerShell. There’s one last point 
to cover about assignment expressions, which we’ll discuss in the next section.
4.2.3
Assignment operations as value expressions
The last thing you need to know about assignment expressions is that they’re expres-
sions.  This  means  that you can use  them anywhere you’d use any  other  kind of 
expression. This lets you initialize multiple variables at once. Let’s initialize 
$a
$b
and 
$c
to the number 3:
PS (1) > $a = $b = $c = 3
Now verify that the assignments worked:
PS (2) > $a, $b, $c 
3
Yes, they did. So what exactly happened? Well, it’s the equivalent of the following 
expression:
PS (3) > $a = ( $b = ( $c = 3 ) )
That is, 
$c
is assigned 3. The expression 
($c = 3)
returns the value 3, which is in 
turn assigned to 
$b
, and the result of that assignment (also 3) is finally assigned to 
$a
so once again, all three variables end up with the same value:
PS (4) > $a, $b, $c 
3
PDF to WORD Converter | Convert PDF to Word, Convert Word to PDF
PDF to Word Converter has accurate output, and PDF to Word Converter doesn't need the support of Adobe Acrobat & Microsoft Word.
how to change page order in pdf acrobat; reverse pdf page order online
TIFF to PDF Converter | Convert TIFF to PDF, Convert PDF to TIFF
doesn't require other third-party such as Adobe Acrobat. a few clicks; Ability to convert PDF documents to and upgrade; Easy to convert multi-page PDF files to
how to reverse pages in pdf; move pages in pdf online
124
CHAPTER 4
O
PERATORS
AND
EXPRESSIONS
Now, because you can “intercept” the expressions with parentheses, you can perform 
additional operations on the values returned from the assignment statements before 
this value is bound in the outer assignment. Here’s an example that does this:
PS (5) > $a = ( $b = ( $c = 3 ) + 1 ) + 1
In this expression, 
$c
gets the value 3. The result of this assignment is returned, and1 
is added to that value, yielding 4, which is then assigned to 
$b
. The result of this second 
assignment also has 1 added to it, so 
$a
is finally assigned 5, as shown in the output:
PS (6) > $a, $b, $c 
3
Now you understand assignment and arithmetic operators. But a language isn’t much 
good if you can’t compare things, so let’s move on to the comparison operators.
4.3
C
OMPARISON
OPERATORS
In this section, we’ll cover what the comparison operators are in PowerShell and how 
they work. These operators are shown in figure 4.4. 
We’ll cover how case sensitivity factors into comparisons and how the operators work 
for scalar values and for collections of values. The ability of these operators to work 
on collections eliminates the need to write looping code in a lot of scenarios.
PowerShell has a sizable number of comparison operators, in large part because 
there are case-sensitive and case-insensitive versions of all the operators. These are 
listed with examples in table 4.3.
-eq     -ne     -gt     -ge     -lt     -le
-ieq    -ine    -igt    -ige    -ilt    -ile 
Comparison operators (case-insensitive)
-ceq    -cne    -cgt    -cge    -clt    -cle 
Comparison operators (case-sensitive)
Figure 4.4 The comparison 
operators in PowerShell. Each 
operator has case-sensitive 
and case-insensitive versions. 
Table 4.3 PowerShell comparison operators
Operator
Description
Example
Result
-eq, –ceq,
–ieq
Equals
5 –eq 5
$true
-ne, –cne, –ine
Not equals
5 –ne 5
$false
DICOM to PDF Converter | Convert DICOM to PDF, Convert PDF to
Adobe Acrobat or any other print drivers when they use DICOM to PDF Converter. Additionally, high-quality image conversion of DICOM & PDF files in single page
reorder pdf page; move pdf pages online
BMP to PDF Converter | Convert Bitmap to PDF, Convert PDF to BMP
interface; Powerful image converter for Bitmap and PDF files; No need for Adobe Acrobat Reader & print driver during conversion; Support
rearrange pages in pdf; how to move pages around in pdf file
C
OMPARISON
OPERATORS
125
In table 4.3, you can see that for each operator there’s a base or unqualified operator 
form, like 
-eq
and its two variants, 
-ceq
and 
-ieq
. The “c” variant is case sensitive 
and the “i” variant is case insensitive. This raises the question, what’s the behavior for 
the base operators with respect to case? The answer is that the unqualified operators 
are case insensitive. All three variants are provided to allow script authors to make 
their intention clear—that they meant a particular behavior rather than accepting 
the default. 
Now that you’re clear on the case-sensitivity issue, let’s move on to discuss the seman-
tics of the comparison operators. We’ll begin in the next section by describing their 
operation on scalar data types; then in the subsequent section, we’ll describe how they 
work with collections of objects.
4.3.1
Scalar comparisons
In this section, we’ll explore how the comparison operators work with scalar objects. 
In particular, we’ll cover their polymorphic behavior with the scalar data types. 
-gt, –cgt, –igt
Greater than
5 –gt 3
$true
-ge, –cge, –ige
Greater than or equal to
5 –ge 3
$true
-lt, –clt, –ilt
Less than
5 –lt 3
$false
-le, –cle, -ile
Less than or equal to
5 –le 3
$false
Table 4.3 PowerShell comparison operators (continued)
Operator
Description
Example
Result
Design decisions
Let’s talk about the most contentious design decision in the PowerShell language. 
And the winner is: why the heck didn’t we use the conventional symbols for compar-
ison like >>=, <, <===, and !=? The answer is that the > and < characters are used 
for output redirection. Because PowerShell is a shell and all shell languages in the 
last 30 years have used > and < for I/O redirection, people expected that PowerShell 
should do the same. During the first public beta of PowerShell, this topic generated 
discussions that went on for months. We looked at a variety of alternatives, such as 
modal parsing where sometimes > meant greater-than and sometimes it meant redi-
rection. We looked at alternative character sequences for the operators like :> or ->
either for redirection or comparison. We did usability tests and held focus groups, 
and in the end, settled on what we had started with. 
The redirection operators are > and <, and the comparison operators are taken from 
the Unix test(1) command. We  expect  that, because these  operators have a 
30-year pedigree, they’re adequate and appropriate to use in PowerShell. (We also 
expect that people will continue to complain about this decision, though hopefully 
not for 30 more years.)
126
CHAPTER 4
O
PERATORS
AND
EXPRESSIONS
Basic comparison rules
As with the assignment operators, the behavior of the comparison operators is signifi-
cantly affected by the type of the left operand. If you’re comparing a number and a 
string, the string will be converted into a number and a numerical comparison will be 
done. If the left operand is a string, the right operand will be converted to a string, 
and the results compared as strings. Let’s look through some examples. First a simple 
numeric comparison:
PS (26) > 01 -eq 001 
True
Because you’re doing a numeric comparison, the leading zeros don’t matter and the 
numbers compare as equal. Now let’s try it when the right operand is a string:
PS (28) > 01 -eq "001" 
True
Following the rule, the right operand is converted from a string into a number; then 
the two are compared and are found to be equal. Finally, try the comparison when 
the left operand is a string:
PS (27) > "01" -eq 001 
False
In this example, the right operand is converted to a string, and consequently they no 
longer compare as equal. You can always use casts to force a particular behavior. In 
the next example, let’s force the left operand to be a number:
PS (29) > [int] "01" -eq 001 
True
And because you forced a numeric comparison, once again they’re equal. 
Type conversions and comparisons
As with any PowerShell operator that involves numbers, when comparisons are done 
in a numeric context, the widening rules are applied. This can produce somewhat 
unexpected results. Here’s an example that illustrates this. In the first part of the 
example, you use a cast to convert the string “123” into a number. Once you’re doing 
the conversion in a numeric context, the numbers get widened to double because the 
right operand is a double; and because 123.4 is larger than 123.0, the 
-lt
operator 
returns true:
PS (37) > [int] "123" -lt 123.4 
True
Now try it using a string as the right operand. The cast forces the left operand to be 
numeric, but the right operand is not yet numeric. It’s converted to the numeric type
C
OMPARISON
OPERATORS
127
of the left operand, which is 
[int]
, not 
[double]
. This means that the value is trun-
cated and the comparison now returns false:
PS (38) > [int] "123" -lt "123.4" 
False
Finally,  if you force the context to be 
[double]
explicitly, the comparison again 
returns true:
PS (39) > [double] "123" -lt "123.4" 
True
Although all these rules  seem  complicated (and, speaking as the guy who imple-
mented them, they are), the results are generally what you’d intuitively expect. This 
satisfies the principle of least astonishment. So most of the time you don’t need to 
worry about the specifics and can let the system take care of the conversions. It’s only 
when things don’t work as expected that you need to understand the details of the 
conversion process. To help you debug cases where this happens, PowerShell provides 
a type-conversion tracing mechanism to help you track down the problems. Chapter 
7 describes how to use this debugging feature. Finally, you can always apply a set of 
casts to override the implicit behavior and force the results you want.
4.3.2
Comparisons and case sensitivity
Next let’s look at the “i” and “c” versions of the comparison operators—the case-
sensitive  and  case-insensitive  versions.  Obviously,  case  sensitivity  only  applies  to 
strings. All the comparison operators have both versions. For example, the 
-eq
opera-
tor has the following variants:
PS (1) > "abc" -eq "ABC" 
True 
PS (2) > "abc" -ieq "ABC" 
True 
PS (3) > "abc" -ceq "ABC" 
False
The default case 
-eq
is case insensitive, as is the explicitly case-insensitive operator 
-ieq
, so in the example, “abc” and 
“ABC”
compare as equal. The 
-ceq
operator is 
case sensitive, so with this operator, “abc” and 
“ABC”
compare as not equal.
The  final  item  to  discuss  with  scalar  comparisons  is  how  things  that  aren’t 
strings and numbers are compared. In this case, the .NET comparison mechanisms 
are used. If the object implements the .
NET
IComparable
interface, then that will 
be used. If not, and if the object on the left side has an 
.Equals()
method that can 
take an object of  the  type of the right  operand,  this is used. If there’s no direct 
mechanism for comparing the two, an attempt will be made to convert the right 
operand into an instance of the type of the left operand, and then PowerShell will
128
CHAPTER 4
O
PERATORS
AND
EXPRESSIONS
try to compare the resulting objects. This lets you compare things such as 
[Date-
Time]
objects, as shown here:
PS (4) > [DateTime] "1/1/2010" -gt [DateTime] "1/1/2009" 
True 
PS (5) > [DateTime] "1/1/2010" -gt [DateTime] "2/1/2010" 
False 
PS (6) >
Not all objects are directly comparable. For example, there’s no direct way to compare 
System.DateTime
object to a 
System.Diagnostics.Process
object:
PS (6) > [DateTime] "1/1/2010" -gt (Get-Process)[0]
The '-gt' operator failed: Cannot convert 
"System.Diagnostics.Process (ALCXMNTR)" to "System.DateTime".. 
At line:1 char:26 
+ [] "1/1/2010" -gt  <<<< (Get-Process)[0]
PS (7) >
In this example, because there’s no direct way to compare a 
DateTime
object to a 
Process
object, the next step is to try to convert the 
Process
object into an instance 
of 
DateTime
. This also failed, and as this is the last step in the comparison algorithm, 
an error message is produced explaining what happened. This is where a human has 
to intervene. The obvious field on a 
Process
object to compare is the 
StartTime
of 
the process. Use the property notation to do this:
PS (7) > [DateTime] "1/1/2010" -gt (Get-Process)[0].StartTime 
False 
PS (8) > [DateTime] "1/1/2011" -gt (Get-Process)[0].StartTime 
True
In this expression, you’re looking to see whether the first element in the list of 
Pro-
cess
objects had a start time greater than the beginning of this year (no) and whether 
it had a start time from before the beginning of next year (obviously true). You can 
use this approach to find all the processes on a computer that started today:
Get-Process | where {$_.starttime -ge [DateTime]::today}
The 
Get-Process
cmdlet returns a list of all the processes on this computer, and the 
where
cmdlet selects those processes where the 
StartTime
property of the process is 
greater than or equal to today. 
NOTE
The 
where
used in the previous example is an alias for the 
Where-Object
cmdlet, which is described in chapter 6.
This completes our discussion of the behavior of the comparison operators with sca-
lar data. We paid a lot of attention to the role types play in comparisons, but so far 
we’ve avoided discussing collection types—lists, arrays, and so on. We’ll get to that in 
the next section.
C
OMPARISON
OPERATORS
129
4.3.3
Using comparison operators with collections
In this section, we’ll focus on the behavior of the comparison operators when they’re 
used with collections of objects. 
Basic comparison operations involving collections
Here’s the basic behavior. If the left operand is an array or collection, the comparison 
operation will return the elements of that collection that match the right operand. 
Let’s illustrate the rule with an example:
PS (1) > 1,2,3,1,2,3,4 -eq 2 
2
This expression searches the list of numbers on the left side and returns those that 
match—the two “2”s. And this works with strings as well:
PS (2) > "one","two","three","two","one" -eq "two" 
two 
two
When processing the array, the scalar comparison rules are used to compare each ele-
ment. In the next example, the left operand is an array containing a mix of numbers 
and strings, and the right operand is the string “2”:
PS (3) > 1,"2",3,2,"1" -eq "2" 
2
Again, it returns the two “2”s. Let’s look at some more examples where you have lead-
ing zeros in the operands. In the first example
PS (4) > 1,"02",3,02,"1" -eq "2" 
2
you only return the number 2 because 2 and “02” compare equally in a numeric con-
text, but “2” and “02” are different in a string context. The same thing happens in the 
next example:
PS (5) > 1,"02",3,02,"1" -eq 2 
2
When  the  elements  are  compared  as  numbers,  they  match.  When  compared  as 
strings, they don’t match because of the leading zero. Now one final example:
PS (6) > 1,"02",3,02,"1" -eq "02" 
02 
2
They both match. In a numeric context, the leading zeros don’t matter; and in the 
string context, the strings match.
Documents you may be interested
Documents you may be interested