pdf annotation in c# : Adding links to pdf SDK application API wpf windows .net sharepoint %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D9-part1625

This expression evaluates to 
true
, indicating that these very different-looking values
are in fact equal. The boolean value 
true
is first converted to the number 1, and the
comparison is done again. Next, the string 
"1"
is converted to the number 1. Since both
values are now the same, the comparison returns 
true
.
4.9.2  Comparison Operators
The comparison operators test the relative order (numerical or alphabetics) of their two
operands:
Less than (
<
)
The 
<
operator evaluates to 
true
if its first operand is less than its second operand;
otherwise it evaluates to 
false
.
Greater than (
>
)
The 
>
operator evaluates to 
true
if its first operand is greater than its second op-
erand; otherwise it evaluates to 
false
.
Less than or equal (
<=
)
The 
<=
operator evaluates to 
true
if its first operand is less than or equal to its
second operand; otherwise it evaluates to 
false
.
Greater than or equal (
>=
)
The 
>=
operator evaluates to 
true
if its first operand is greater than or equal to its
second operand; otherwise it evaluates to 
false
.
The operands of these comparison operators may be of any type. Comparison can be
performed only on numbers and strings, however, so operands that are not numbers
or strings are converted. Comparison and conversion occur as follows:
• If either operand evaluates to an object, that object is converted to a primitive value
as described at the end of §3.8.3: if its 
valueOf()
method returns a primitive value,
that value is used. Otherwise, the return value of its 
toString()
method is used.
• If, after any required object-to-primitive conversion, both operands are strings, the
two strings are compared, using alphabetical order, where “alphabetical order” is
defined by the numerical order of the 16-bit Unicode values that make up the
strings.
• If, after object-to-primitive conversion, at least one operand is not a string, both
operands are converted to numbers and compared numerically. 
0
and 
-0
are con-
sidered equal. 
Infinity
is larger than any number other than itself, and
-Infinity
is smaller than any number other than itself. If either operand is (or
converts to) 
NaN
, then the comparison operator always returns 
false
.
Remember that JavaScript strings are sequences of 16-bit integer values, and that string
comparison is just a numerical comparison of the values in the two strings. The nu-
merical encoding order defined by Unicode may not match the traditional collation
order used in any particular language or locale. Note in particular that string compar-
ison is case-sensitive, and all capital ASCII letters are “less than” all lowercase ASCII
4.9  Relational Expressions | 73
Core JavaScript
Adding links to pdf - insert, remove PDF links in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Free C# example code is offered for users to edit PDF document hyperlink (url), like inserting and deleting
add hyperlink to pdf online; active links in pdf
Adding links to pdf - VB.NET PDF url edit library: insert, remove PDF links in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Help to Insert a Hyperlink to Specified PDF Document Page
add hyperlinks pdf file; add url to pdf
letters. This rule can cause confusing results if you do not expect it. For example, ac-
cording to the 
<
operator, the string “Zoo” comes before the string “aardvark”.
For a more robust string-comparison algorithm, see the 
String.localeCompare()
meth-
od, which also takes locale-specific definitions of alphabetical order into account. For
case-insensitive comparisons, you must first convert the strings to all lowercase or all
uppercase using 
String.toLowerCase()
or 
String.toUpperCase()
.
Both the 
+
operator and the comparison operators behave differently for numeric and
string operands. 
+
favors strings: it performs concatenation if either operand is a string.
The comparison operators favor numbers and only perform string comparison if both
operands are strings:
1 + 2        // Addition. Result is 3.
"1" + "2"    // Concatenation. Result is "12".
"1" + 2      // Concatenation. 2 is converted to "2". Result is "12".
11 < 3       // Numeric comparison. Result is false.
"11" < "3"   // String comparison. Result is true.
"11" < 3     // Numeric comparison. "11" converted to 11. Result is false.
"one" < 3    // Numeric comparison. "one" converted to NaN. Result is false.
Finally, note that the 
<=
(less than or equal) and 
>=
(greater than or equal) operators do
not rely on the equality or strict equality operators for determining whether two values
are “equal.” Instead, the less-than-or-equal operator is simply defined as “not greater
than,” and the greater-than-or-equal operator is defined as “not less than.” The one
exception occurs when either operand is (or converts to) 
NaN
, in which case all four
comparison operators return 
false
.
4.9.3  The in Operator
The 
in
operator expects a left-side operand that is or can be converted to a string. It
expects a right-side operand that is an object. It evaluates to 
true
if the left-side value
is the name of a property of the right-side object. For example:
var point = { x:1, y:1 };  // Define an object
"x" in point               // => true: object has property named "x"
"z" in point               // => false: object has no "z" property.
"toString" in point        // => true: object inherits toString method
var data = [7,8,9];        // An array with elements 0, 1, and 2
"0" in data                // => true: array has an element "0"
1 in data                  // => true: numbers are converted to strings
3 in data                  // => false: no element 3
4.9.4  The instanceof Operator
The 
instanceof
operator expects a left-side operand that is an object and a right-side
operand that identifies a class of objects. The operator evaluates to 
true
if the left-side
object is an instance of the right-side class and evaluates to 
false
otherwise. Chap-
ter 9 explains that, in JavaScript, classes of objects are defined by the constructor
74 | Chapter 4: Expressions and Operators
C# Create PDF Library SDK to convert PDF from other file formats
Create and save editable PDF with a blank page, bookmarks, links, signatures, etc. Besides, using this PDF document metadata adding control, you can
adding links to pdf in preview; c# read pdf from url
VB.NET PowerPoint: Add Image to PowerPoint Document Slide/Page
detail guides on these functions through left menu links. guide on C#.NET PPT image adding library. powerful & profession imaging controls, PDF document, tiff
add links pdf document; add hyperlink pdf file
function that initializes them. Thus, the right-side operand of 
instanceof
should be a
function. Here are examples:
var d = new Date();  // Create a new object with the Date() constructor
d instanceof Date;   // Evaluates to true; d was created with Date()
d instanceof Object; // Evaluates to true; all objects are instances of Object
d instanceof Number; // Evaluates to false; d is not a Number object
var a = [1, 2, 3];   // Create an array with array literal syntax
a instanceof Array;  // Evaluates to true; a is an array
a instanceof Object; // Evaluates to true; all arrays are objects
a instanceof RegExp; // Evaluates to false; arrays are not regular expressions
Note that all objects are instances of 
Object
instanceof
considers the “superclasses”
when deciding whether an object is an instance of a class. If the left-side operand of
instanceof
is not an object, 
instanceof
returns 
false
. If the right-hand side is not a
function, it throws a 
TypeError
.
In order to understand how the 
instanceof
operator works, you must understand the
“prototype chain.” This is JavaScript’s inheritance mechanism, and it is described in
§6.2.2. To evaluate the expression 
o instanceof f
, JavaScript evaluates 
f.prototype
,
and then looks for that value in the prototype chain of 
o
. If it finds it, then o is an
instance of f (or of a superclass of f) and the operator returns 
true
. If 
f.prototype
is not
one of the values in the prototype chain of 
o
, then 
o
is not an instance of f and
instanceof
returns 
false
.
4.10  Logical Expressions
The logical operators 
&&
||
, and 
!
perform Boolean algebra and are often used in con-
junction with the relational operators to combine two relational expressions into one
more complex expression. These operators are described in the subsections that follow.
In order to fully understand them, you may want to review the concept of “truthy” and
“falsy” values introduced in §3.3.
4.10.1  Logical AND (&&)
The 
&&
operator can be understood at three different levels. At the simplest level, when
used with boolean operands, 
&&
performs the Boolean AND operation on the two val-
ues: it returns 
true
if and only if both its first operand and its second operand are
true
. If one or both of these operands is 
false
, it returns 
false
.
&&
is often used as a conjunction to join two relational expressions:
x == 0 && y == 0   // true if, and only if x and y are both 0
Relational expressions always evaluate to 
true
or 
false
, so when used like this, the
&&
operator itself returns 
true
or 
false
. Relational operators have higher precedence
than 
&&
(and 
||
), so expressions like these can safely be written without parentheses.
But 
&&
does not require that its operands be boolean values. Recall that all JavaScript
values are either “truthy” or “falsy.” (See §3.3 for details. The falsy values are 
false
,
4.10  Logical Expressions | 75
Core JavaScript
View Images & Documents in Web Image Viewer | Online Tutorials
document or image file, like Word, PDF or TIFF other mature image viewing features, like adding or deleting page And you can find the links to these professional
clickable pdf links; adding hyperlinks to pdf documents
null
undefined
0
-0
NaN
, and 
""
. All other values, including all objects, are truthy.)
The second level at which 
&&
can be understood is as a Boolean AND operator for truthy
and falsy values. If both operands are truthy, the operator returns a truthy value. Oth-
erwise, one or both operands must be falsy, and the operator returns a falsy value. In
JavaScript, any expression or statement that expects a boolean value will work with a
truthy or falsy value, so the fact that 
&&
does not always return 
true
or 
false
does not
cause practical problems.
Notice that the description above says that the operator returns “a truthy value” or “a
falsy value,” but does not specify what that value is. For that, we need to describe 
&&
at the third and final level. This operator starts by evaluating its first operand, the
expression on its left. If the value on the left is falsy, the value of the entire expression
must also be falsy, so 
&&
simply returns the value on the left and does not even evaluate
the expression on the right.
On the other hand, if the value on the left is truthy, then the overall value of the ex-
pression depends on the value on the right-hand side. If the value on the right is truthy,
then the overall value must be truthy, and if the value on the right is falsy, then the
overall value must be falsy. So when the value on the left is truthy, the 
&&
operator
evaluates and returns the value on the right:
var o = { x : 1 };
var p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x
It is important to understand that 
&&
may or may not evaluate its right-side operand.
In the code above, the variable 
p
is set to 
null
, and the expression 
p.x
would, if
evaluated, cause a TypeError. But the code uses 
&&
in an idiomatic way so that 
p.x
is
evaluated only if 
p
is truthy—not 
null
or 
undefined
.
The behavior of 
&&
is sometimes called “short circuiting,” and you may sometimes see
code that purposely exploits this behavior to conditionally execute code. For example,
the following two lines of JavaScript code have equivalent effects:
if (a == b) stop();   // Invoke stop() only if a == b
(a == b) && stop();   // This does the same thing
In general, you must be careful whenever you write an expression with side effects
(assignments, increments, decrements, or function invocations) on the right-hand side
of 
&&
. Whether those side effects occur depends on the value of the left-hand side.
Despite the somewhat complex way that this operator actually works, it is most com-
monly used as a simple Boolean algebra operator that works on truthy and falsy values.
4.10.2  Logical OR (||)
The 
||
operator performs the Boolean OR operation on its two operands. If one or both
operands is truthy, it returns a truthy value. If both operands are falsy, it returns a falsy
value.
76 | Chapter 4: Expressions and Operators
Although the 
||
operator is most often used simply as a Boolean OR operator, it, like
the 
&&
operator, has more complex behavior. It starts by evaluating its first operand,
the expression on its left. If the value of this first operand is truthy, it returns that truthy
value. Otherwise, it evaluates its second operand, the expression on its right, and re-
turns the value of that expression.
As with the 
&&
operator, you should avoid right-side operands that include side effects,
unless you purposely want to use the fact that the right-side expression may not be
evaluated.
An idiomatic usage of this operator is to select the first truthy value in a set of
alternatives:
// If max_width is defined, use that.  Otherwise look for a value in
// the preferences object.  If that is not defined use a hard-coded constant.
var max = max_width || preferences.max_width || 500;
This idiom is often used in function bodies to supply default values for parameters:
// Copy the properties of o to p, and return p
function copy(o, p) {
p = p || {};  // If no object passed for p, use a newly created object.
// function body goes here
}
4.10.3  Logical NOT (!)
The 
!
operator is a unary operator; it is placed before a single operand. Its purpose is
to invert the boolean value of its operand. For example, if 
x
is truthy 
!x
evaluates to
false
. If 
x
is falsy, then 
!x
is 
true
.
Unlike the 
&&
and 
||
operators, the 
!
operator converts its operand to a boolean value
(using the rules described in Chapter 3) before inverting the converted value. This
means that 
!
always returns 
true
or 
false
, and that you can convert any value 
x
to its
equivalent boolean value by applying this operator twice: 
!!x
(see §3.8.2).
As a unary operator, 
!
has high precedence and binds tightly. If you want to invert the
value of an expression like 
p && q
, you need to use parentheses: 
!(p && q)
. It is worth
noting two theorems of Boolean algebra here that we can express using JavaScript
syntax:
// These two equalities hold for any values of p and q
!(p && q) === !p || !q
!(p || q) === !p && !q
4.11  Assignment Expressions
JavaScript uses the 
=
operator to assign a value to a variable or property. For example:
i = 0           // Set the variable i to 0.
o.x = 1         // Set the property x of object o to 1.
4.11  Assignment Expressions | 77
Core JavaScript
The 
=
operator expects its left-side operand to be an lvalue: a variable or object property
(or array element). It expects its right-side operand to be an arbitrary value of any type.
The value of an assignment expression is the value of the right-side operand. As a side
effect, the 
=
operator assigns the value on the right to the variable or property on the
left so that future references to the variable or property evaluate to the value.
Although assignment expressions are usually quite simple, you may sometimes see the
value of an assignment expression used as part of a larger expression. For example, you
can assign and test a value in the same expression with code like this:
(a = b) == 0
If you do this, be sure you are clear on the difference between the 
=
and 
==
operators!
Note that 
=
has very low precedence and parentheses are usually necessary when the
value of an assignment is to be used in a larger expression.
The assignment operator has right-to-left associativity, which means that when
multiple assignment operators appear in an expression, they are evaluated from right
to left. Thus, you can write code like this to assign a single value to multiple variables:
i = j = k = 0;       // Initialize 3 variables to 0
4.11.1  Assignment with Operation
Besides the normal 
=
assignment operator, JavaScript supports a number of other as-
signment operators that provide shortcuts by combining assignment with some other
operation. For example, the 
+=
operator performs addition and assignment. The fol-
lowing expression:
total += sales_tax
is equivalent to this one:
total = total + sales_tax
As you might expect, the 
+=
operator works for numbers or strings. For numeric oper-
ands, it performs addition and assignment; for string operands, it performs concate-
nation and assignment.
Similar operators include 
-=
*=
&=
, and so on. Table 4-2 lists them all.
Table 4-2. Assignment operators
Operator Example
Equivalent
+=
a += b
a = a + b
-=
a -= b
a = a - b
*=
a *= b
a = a * b
/=
a /= b
a = a / b
%=
a %= b
a = a % b
<<=
a <<= b
a = a << b
78 | Chapter 4: Expressions and Operators
Operator Example
Equivalent
>>=
a >>= b
a = a >> b
>>>=
a >>>= b
a = a >>> b
&=
a &= b
a = a & b
|=
a |= b
a = a | b
^=
a ^= b
a = a ^ b
In most cases, the expression:
a op= b
where 
op
is an operator, is equivalent to the expression:
a = a op b
In the first line, the expression 
a
is evaluated once. In the second it is evaluated twice.
The two cases will differ only if 
a
includes side effects such as a function call or an
increment operator. The following two assignments, for example, are not the same:
data[i++] *= 2;
data[i++] = data[i++] * 2;
4.12  Evaluation Expressions
Like many interpreted languages, JavaScript has the ability to interpret strings of Java-
Script source code, evaluating them to produce a value. JavaScript does this with the
global function 
eval()
:
eval("3+2")    // => 5
Dynamic evaluation of strings of source code is a powerful language feature that is
almost never necessary in practice. If you find yourself using 
eval()
, you should think
carefully about whether you really need to use it.
The subsections below explain the basic use of 
eval()
and then explain two restricted
versions of it that have less impact on the optimizer.
Is eval() a Function or an Operator?
eval()
is a function, but it is included in this chapter on expressions because it really
should have been an operator. The earliest versions of the language defined an 
eval()
function, and ever since then language designers and interpreter writers have been
placing restrictions on it that make it more and more operator-like. Modern JavaScript
interpreters perform a lot of code analysis and optimization. The problem with
eval()
is that the code it evaluates is, in general, unanalyzable. Generally speaking, if
a function calls 
eval()
, the interpreter cannot optimize that function. The problem with
defining 
eval()
as a function is that it can be given other names:
var f = eval;
var g = f;
4.12  Evaluation Expressions | 79
Core JavaScript
If this is allowed, then the interpreter can’t safely optimize any function that calls 
g()
.
This issue could have been avoided if 
eval
was an operator (and a reserved word). We’ll
learn below (in §4.12.2 and §4.12.3) about restrictions placed on 
eval()
to make it
more operator-like.
4.12.1  eval()
eval()
expects one argument. If you pass any value other than a string, it simply returns
that value. If you pass a string, it attempts to parse the string as JavaScript code, throw-
ing a SyntaxError if it fails. If it successfully parses the string, then it evaluates the code
and returns the value of the last expression or statement in the string or 
undefined
if
the last expression or statement had no value. If the string throws an exception, the
eval()
propagates that expression.
The key thing about 
eval()
(when invoked like this) is that it uses the variable envi-
ronment of the code that calls it. That is, it looks up the values of variables and defines
new variables and functions in the same way that local code does. If a function defines
a local variable 
x
and then calls 
eval("x")
, it will obtain the value of the local variable.
If it calls 
eval("x=1")
, it changes the value of the local variable. And if the function calls
eval("var y = 3;")
, it has declared a new local variable 
y
. Similarly a function can
declare a local function with code like this:
eval("function f() { return x+1; }");
If you call 
eval()
from top-level code, it operates on global variables and global func-
tions, of course.
Note that the string of code you pass to 
eval()
must make syntactic sense on its own—
you cannot use it to paste code fragments into a function. It makes no sense to write
eval("return;")
, for example, because 
return
is only legal within functions, and the
fact that the evaluated string uses the same variable environment as the calling function
does not make it part of that function. If your string would make sense as a standalone
script (even a very short one like 
x=0
), it is legal to pass to 
eval()
. Otherwise 
eval()
will throw a SyntaxError.
4.12.2  Global eval()
It is the ability of 
eval()
to change local variables that is so problematic to JavaScript
optimizers. As a workaround, however, interpreters simply do less optimization on any
function that calls 
eval()
. But what should a JavaScript interpreter do, however, if a
script defines an alias for 
eval()
and then calls that function by another name? In order
to simplify the job of JavaScript implementors, the ECMAScript 3 standard declared
that interpreters did not have to allow this. If the 
eval()
function was invoked by any
name other than “eval”, it was allowed to throw an EvalError.
In practice, most implementors did something else. When invoked by any other name,
eval()
would evaluate the string as if it were top-level global code. The evaluated code
might define new global variables or global functions, and it might set global variables,
80 | Chapter 4: Expressions and Operators
but it could not use or modify any variables local to the calling function, and would
not, therefore, interfere with local optimizations.
ECMAScript 5 deprecates EvalError and standardizes the de facto behavior of 
eval()
.
A “direct eval” is a call to the 
eval()
function with an expression that uses the exact,
unqualified name “eval” (which is beginning to feel like a reserved word). Direct calls
to 
eval()
use the variable environment of the calling context. Any other call—an
indirect call—uses the global object as its variable environment and cannot read, write,
or define local variables or functions. The following code demonstrates:
var geval = eval;                 // Using another name does a global eval
var x = "global", y = "global";   // Two global variables
function f() {                    // This function does a local eval
var x = "local";              // Define a local variable
eval("x += 'changed';");      // Direct eval sets local variable
return x;                     // Return changed local variable
}
function g() {                    // This function does a global eval
var y = "local";              // A local variable
geval("y += 'changed';");     // Indirect eval sets global variable
return y;                     // Return unchanged local variable
}
console.log(f(), x); // Local variable changed: prints "localchanged global": 
console.log(g(), y); // Global variable changed: prints "local globalchanged":
Notice that the ability to do a global eval is not just an accommodation to the needs of
the optimizer, it is actually a tremendously useful feature: it allows you to execute
strings of code as if they were independent, top-level scripts. As noted at the beginning
of this section, it is rare to truly need to evaluate a string of code. But if you do find it
necessary, you are more likely to want to do a global eval than a local eval.
Before IE9, IE differs from other browsers: it does not do a global eval when 
eval()
is
invoked by a different name. (It doesn’t throw an EvalError either: it simply does a local
eval.) But IE does define a global function named 
execScript()
that executes its string
argument as if it were a top-level script. (Unlike 
eval()
, however, 
execScript()
always
returns 
null
.)
4.12.3  Strict eval()
ECMAScript 5 strict mode (see §5.7.3) imposes further restrictions on the behavior of
the 
eval()
function and even on the use of the identifier “eval”. When 
eval()
is called
from strict mode code, or when the string of code to be evaluated itself begins with a
“use strict” directive, then 
eval()
does a local eval with a private variable environment.
This means that in strict mode, evaluated code can query and set local variables, but it
cannot define new variables or functions in the local scope.
Furthermore, strict mode makes 
eval()
even more operator-like by effectively making
“eval” into a reserved word. You are not allowed to overwrite the 
eval()
function with
a new value. And you are not allowed to declare a variable, function, function param-
eter, or catch block parameter with the name “eval”.
4.12  Evaluation Expressions | 81
Core JavaScript
4.13  Miscellaneous Operators
JavaScript supports a number of other miscellaneous operators, described in the fol-
lowing sections.
4.13.1  The Conditional Operator (?:)
The conditional operator is the only ternary operator (three operands) in JavaScript
and is sometimes actually called the ternary operator. This operator is sometimes writ-
ten 
?:
, although it does not appear quite that way in code. Because this operator has
three operands, the first goes before the 
?
, the second goes between the 
?
and the 
:
,
and the third goes after the 
:
. It is used like this:
x > 0 ? x : -x     // The absolute value of x
The operands of the conditional operator may be of any type. The first operand is
evaluated and interpreted as a boolean. If the value of the first operand is truthy, then
the second operand is evaluated, and its value is returned. Otherwise, if the first operand
is falsy, then the third operand is evaluated and its value is returned. Only one of the
second and third operands is evaluated, never both.
While you can achieve similar results using the 
if
statement (§5.4.1), the 
?:
operator
often provides a handy shortcut. Here is a typical usage, which checks to be sure that
a variable is defined (and has a meaningful, truthy value) and uses it if so or provides
a default value if not:
greeting = "hello " + (username ? username : "there");
This is equivalent to, but more compact than, the following 
if
statement:
greeting = "hello ";
if (username)
greeting += username;
else
greeting += "there";
4.13.2  The typeof Operator
typeof
is a unary operator that is placed before its single operand, which can be of any
type. Its value is a string that specifies the type of the operand. The following table
specifies the value of the 
typeof
operator for any JavaScript value:
x
typeof x
undefined
"undefined"
null
"object"
true
or 
false
"boolean"
any number or 
NaN
"number"
any string
"string"
82 | Chapter 4: Expressions and Operators
Documents you may be interested
Documents you may be interested