open pdf and draw c# : Add hyperlinks to pdf online SDK control API .net web page winforms sharepoint %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D8-part1614

Operator
Operation
A N
Types
delete
Remove a property
R 1
lval→bool
typeof
Determine type of operand
R 1
any→str
void
Return undefined value
R
1
any→undef
*
/
%
Multiply, divide, remainder
L
2
num,num→num
+
-
Add, subtract
L 2
num,num→num
+
Concatenate strings
L
2
str,str→str
<<
Shift left
L 2
int,int→int
>>
Shift right with sign extension
L 2
int,int→int
>>>
Shift right with zero extension
L
2
int,int→int
<
<=
,
>
>=
Compare in numeric order
L 2
num,num→bool
<
<=
,
>
>=
Compare in alphabetic order
L 2
str,str→bool
instanceof
Test object class
L 2
obj,func→bool
in
Test whether property exists
L
2
str,obj→bool
==
Test for equality
L 2
any,any→bool
!=
Test for inequality
L 2
any,any→bool
===
Test for strict equality
L 2
any,any→bool
!==
Test for strict inequality
L
2
any,any→bool
&
Compute bitwise AND
L
2
int,int→int
^
Compute bitwise XOR
L
2
int,int→int
|
Compute bitwise OR
L
2
int,int→int
&&
Compute logical AND
L
2
any,any→any
||
Compute logical OR
L
2
any,any→any
?:
Choose 2nd or 3rd operand
R
3
bool,any,any→any
=
Assign to a variable or property
R 2
lval,any→any
*=
/=
%=
+=
,
Operate and assign
R 2
lval,any→any
-=
&=
^=
|=
,
<<=
>>=
>>>=
,
Discard 1st operand, return second
L
2
any,any→any
4.7.1  Number of Operands
Operators  can  be  categorized  based  on  the  number  of  operands  they  expect  (their
arity). Most JavaScript operators, like the 
*
multiplication operator, are binary opera-
tors that combine two expressions into a single, more complex expression. That is, they
expect  two  operands. JavaScript  also  supports a number  of  unary  operators, which
convert a single expression into a single, more complex expression. The 
operator in
4.7  Operator Overview | 63
Core JavaScript
Add hyperlinks to pdf online - 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 links to pdf online; pdf edit hyperlink
Add hyperlinks to pdf online - 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
adding hyperlinks to pdf files; pdf reader link
the expression 
−x
is a unary operator that performs the operation of negation on the
operand 
x
.  Finally, JavaScript  supports one  ternary operator,  the conditional  opera-
tor 
?:
, which combines three expressions into a single expression.
4.7.2  Operand and Result Type
Some operators work on values of any type, but most expect their operands to be of a
specific type, and most operators return (or evaluate to) a value of a specific type. The
Types column in Table 4-1 specifies operand types (before the arrow) and result type
(after the arrow) for the operators.
JavaScript operators usually convert the type (see §3.8) of their operands as needed.
The  multiplication  operator 
*
expects  numeric  operands,  but  the  expression 
"3"  *
"5"
is legal because JavaScript can convert the operands to numbers. The value of this
expression is the number 15, not the string “15”, of course. Remember also that every
JavaScript value is either “truthy” or “falsy,” so operators that expect boolean operands
will work with an operand of any type.
Some operators behave differently depending on  the  type of the operands used  with
them. Most notably, the 
+
operator adds numeric operands  but  concatenates  string
operands. Similarly,  the comparison  operators such  as 
<
perform  comparison in nu-
merical or alphabetical order depending on the type of the operands. The descriptions
of individual operators explain their type-dependencies and specify what type conver-
sions they perform.
4.7.3  Lvalues
Notice  that  the  assignment  operators  and  a  few  of  the  other  operators  listed  in
Table 4-1 expect an operand of type 
lval
. lvalue is a  historical term that means “an
expression  that  can legally  appear  on  the left side  of  an assignment expression.” In
JavaScript,  variables,  properties  of  objects,  and  elements  of  arrays  are  lvalues.  The
ECMAScript specification allows built-in functions to return lvalues but does not define
any functions that behave that way.
4.7.4  Operator Side Effects
Evaluating a simple expression like 
2 * 3
never affects the state of your program, and
any future computation your program performs will be unaffected by that evaluation.
Some expressions, however, have side effects, and their evaluation may affect the result
of future evaluations. The assignment operators are the most obvious example: if you
assign a value to a variable or property, that changes the value of any expression that
uses that variable or property. The 
++
and 
--
increment and decrement operators are
similar, since they perform an implicit assignment. The 
delete
operator also has side
effects:  deleting  a  property  is  like  (but  not  the  same  as)  assigning 
undefined
to  the
property.
64 | Chapter 4: Expressions and Operators
VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.
Turn PDF images to HTML images in VB.NET. Embed PDF hyperlinks to HTML links in VB.NET. Convert PDF to HTML in VB.NET Demo Code. Add necessary references:
add links to pdf acrobat; add hyperlinks to pdf
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
Embed PDF hyperlinks to HTML links. How to Use C#.NET Demo Code to Convert PDF Document to HTML5 Files in C#.NET Class. Add necessary references:
add a link to a pdf file; add link to pdf acrobat
No  other JavaScript  operators  have  side  effects,  but  function invocation  and object
creation expressions will have side effects if any of the operators used in the function
or constructor body have side effects.
4.7.5  Operator Precedence
The operators listed in Table 4-1 are arranged in order from high precedence to low
precedence, with horizontal lines separating groups of operators at the same precedence
level. Operator precedence controls the order in which operations are performed. Op-
erators with higher precedence (nearer the top of the table) are performed before those
with lower precedence (nearer to the bottom).
Consider the following expression:
w = x + y*z;
The multiplication operator 
*
has a higher precedence than the addition operator 
+
, so
the multiplication is performed before the addition. Furthermore, the assignment op-
erator 
=
has the lowest precedence, so the assignment is performed after all the opera-
tions on the right side are completed.
Operator precedence can be overridden with the explicit use of parentheses. To force
the addition in the previous example to be performed first, write:
w = (x + y)*z;
Note that property access and invocation expressions have higher precedence than any
of the operators listed in Table 4-1. Consider this expression:
typeof my.functions[x](y)
Although 
typeof
is one of the highest-priority operators, the 
typeof
operation is per-
formed on the result of the two property accesses and the function invocation.
In practice, if you are at all unsure about the precedence of your operators, the simplest
thing to do is to use parentheses to make the evaluation order explicit. The rules that
are important to know are these: multiplication and division are performed before ad-
dition and subtraction, and assignment has very low precedence and is almost always
performed last.
4.7.6  Operator Associativity
In Table 4-1, the column labeled A specifies the associativity of the operator. A value
of L specifies left-to-right associativity, and a value of R specifies right-to-left associa-
tivity.  The associativity of an operator specifies  the  order in which operations of the
same precedence are performed. Left-to-right associativity means that operations are
performed from left  to  right.  For example, the subtraction operator  has left-to-right
associativity, so:
w = x - y - z;
4.7  Operator Overview | 65
Core JavaScript
VB.NET PDF Page Replace Library: replace PDF pages in C#.net, ASP.
all PDF page contents in VB.NET, including text, image, hyperlinks, etc. Replace a Page (in a PDFDocument Object) by a PDF Page Object. Add necessary references:
add email link to pdf; add hyperlink pdf file
VB.NET PDF Thumbnail Create SDK: Draw thumbnail images for PDF in
PDF document is an easy work and gives quick access to PDF page and file, or even hyperlinks. How to VB.NET: Create Thumbnail for PDF. Add necessary references:
add a link to a pdf in preview; adding hyperlinks to a pdf
is the same as:
w = ((x - y) - z);
On the other hand, the following expressions:
x = ~-y;
w = x = y = z;
q = a?b:c?d:e?f:g;
are equivalent to:
x = ~(-y); w = (x = (y = z)); q =
a?b:(c?d:(e?f:g));
because  the  unary,  assignment,  and  ternary  conditional  operators  have  right-to-left
associativity.
4.7.7  Order of Evaluation
Operator  precedence  and  associativity  specify  the  order  in  which  operations  are
performed  in a complex  expression, but they  do not  specify the order in  which the
subexpressions are evaluated. JavaScript always evaluates expressions in strictly left-
to-right order. In the expression 
w=x+y*z
, for example, the subexpression 
w
is evaluated
first, followed by 
x
y
, and 
z
. Then the values of 
y
and 
z
are multiplied, added to the
value of 
x
, and assigned to the variable or property specified by expression 
w
. Adding
parentheses to the expressions can change the relative order of the multiplication, ad-
dition, and assignment, but not the left-to-right order of evaluation.
Order of evaluation only makes a difference if any of the expressions being evaluated
has side effects that affect the value of another expression. If expression 
x
increments
a  variable that  is used by  expression 
z
,  then  the fact  that 
x
is  evaluated  before 
z
is
important.
4.8  Arithmetic Expressions
This section covers the operators that perform arithmetic or other numerical manipu-
lations on their operands. The multiplication, division, and subtraction operators are
straightforward  and  are covered  first.  The  addition operator gets  a  subsection of  its
own because it can also perform string concatenation and has some unusual type con-
version rules. The unary operators and the bitwise operators are also covered in sub-
sections of their own.
The basic arithmetic operators are 
*
(multiplication), 
/
(division), 
%
(modulo: remainder
after division), 
+
(addition), and 
-
(subtraction). As noted, we’ll discuss the 
+
operator
in a section of its own. The other basic four operators simply evaluate their operands,
convert the values to numbers if necessary, and then compute the product, quotient,
remainder, or difference between the values. Non-numeric operands that cannot con-
vert to numbers convert to the 
NaN
value. If either operand is (or converts to) 
NaN
, the
result of the operation is also 
NaN
.
66 | Chapter 4: Expressions and Operators
Download from Wow! eBook <www.wowebook.com>
.NET PDF SDK | Read & Processing PDF files
by this .NET Imaging PDF Reader Add-on. Include extraction of text, hyperlinks, bookmarks and metadata; Annotate and redact in PDF documents; Fully support all
adding links to pdf; pdf hyperlinks
PDF Image Viewer| What is PDF
advanced capabilities, such as text extraction, hyperlinks, bookmarks and Note: PDF processing and conversion is excluded in NET Imaging SDK, you may add it on
adding a link to a pdf in preview; pdf link open in new window
The 
/
operator divides its first operand by its second. If you are used to programming
languages that distinguish between integer and floating-point numbers, you might ex-
pect to  get  an integer  result  when you  divide  one integer by  another.  In JavaScript,
however, all numbers are floating-point, so all division operations have floating-point
results: 
5/2
evaluates to 
2.5
, not 
2
. Division by zero yields positive or negative infinity,
while 
0/0
evaluates to 
NaN
: neither of these cases raises an error.
The 
%
operator computes the first operand modulo the second operand. In other words,
it returns the remainder after whole-number division of the first operand by the second
operand. The sign of the result is the same as the sign of the first operand. For example,
5 % 2
evaluates to 
1
and 
-5 % 2
evaluates to 
-1
.
While the modulo operator is typically used with integer operands, it also works for
floating-point values. For example, 
6.5 % 2.1
evaluates to 
0.2
.
4.8.1  The + Operator
The binary 
+
operator adds numeric operands or concatenates string operands:
1 + 2                        // => 3
"hello" + " " + "there"      // => "hello there"
"1" + "2"                    // => "12"
When the values of both operands are numbers, or are both strings, then it is obvious
what the 
+
operator does. In any other case, however, type conversion is necessary, and
the operation to be performed depends on the conversion performed. The conversions
rules for 
+
give priority to string concatenation: if either of the operands is a string or
an object that converts to a string, the other operand is converted to a string and con-
catenation is performed. Addition is performed only if neither operand is string-like.
Technically, the 
+
operator behaves like this:
• If  either of  its operand values is an object, it converts it to a primitive  using the
object-to-primitive algorithm described in §3.8.3:  Date objects are converted by
their 
toString()
method, and all other objects are converted via 
valueOf()
, if that
method returns a  primitive value. Most  objects  do not have  a  useful 
valueOf()
method, however, so they are converted via 
toString()
as well.
• After object-to-primitive conversion, if either operand is a string, the other is con-
verted to a string and concatenation is performed.
• Otherwise,  both operands  are converted to numbers (or to 
NaN
)  and addition is
performed.
Here are some examples:
1 + 2         // => 3: addition
"1" + "2"     // => "12": concatenation
"1" + 2       // => "12": concatenation after number-to-string
1 + {}        // => "1[object Object]": concatenation after object-to-string
true + true   // => 2: addition after boolean-to-number
4.8  Arithmetic Expressions | 67
Core JavaScript
2 + null      // => 2: addition after null converts to 0
2 + undefined // => NaN: addition after undefined converts to NaN
Finally, it is important to note that when the 
+
operator is used with strings and num-
bers, it may not be associative. That is, the result may depend on the order in which
operations are performed. For example:
1 + 2 + " blind mice";    // => "3 blind mice"
1 + (2 + " blind mice");  // => "12 blind mice"
The first line has no parentheses, and the 
+
operator has left-to-right associativity, so
the two numbers are added first, and their sum is concatenated with the string. In the
second line, parentheses alter this order of operations: the number 2 is concatenated
with the string to produce a new string. Then the number 1 is concatenated with the
new string to produce the final result.
4.8.2  Unary Arithmetic Operators
Unary operators modify the value of a single operand to produce a new value. In Java-
Script, the unary operators all have high precedence and are all right-associative. The
arithmetic unary operators described in this section (
+
-
++
, and 
--
) all convert their
single  operand  to  a  number,  if  necessary.  Note  that  the  punctuation  characters 
+
and 
-
are used as both unary and binary operators.
The unary arithmetic operators are the following:
Unary plus (
+
)
The unary plus operator converts its operand to a number (or to 
NaN
) and returns
that converted  value.  When  used  with  an  operand  that  is  already  a  number,  it
doesn’t do anything.
Unary minus (
-
)
When 
-
is used as a unary operator, it converts its operand to a number, if necessary,
and then changes the sign of the result.
Increment (
++
)
The 
++
operator increments (i.e., adds 1 to) its single operand, which must be an
lvalue (a variable, an element of an array, or a property of an object). The operator
converts its operand to a number, adds 1 to that number, and assigns the incre-
mented value back into the variable, element, or property.
The return value of the 
++
operator depends on its position relative to the operand.
When used before the operand, where it is known as the pre-increment operator,
it  increments  the  operand  and  evaluates  to  the  incremented  value  of  that
operand. When used after the operand, where it is known as the post-increment
operator, it increments its operand but evaluates to the unincremented value of that
operand. Consider the difference between these two lines of code:
var i = 1, j = ++i;    // i and j are both 2
var i = 1, j = i++;    // i is 2, j is 1
68 | Chapter 4: Expressions and Operators
Note that the expression 
++x
is not always the same as 
x=x+1
. The 
++
operator never
performs  string  concatenation:  it  always converts  its  operand  to  a  number  and
increments it. If 
x
is the string “1”, 
++x
is the number 2, but 
x+1
is the string “11”.
Also note that, because of JavaScript’s automatic semicolon insertion, you cannot
insert a line break between the post-increment operator and the operand that pre-
cedes it. If you do so, JavaScript will treat the operand as a complete statement by
itself and insert a semicolon before it.
This operator, in both its pre- and post-increment forms, is most commonly used
to increment a counter that controls a 
for
loop (§5.5.3).
Decrement (
--
)
The 
--
operator expects an lvalue operand. It converts the value of the operand to
a  number, subtracts  1,  and assigns the decremented value back to the operand.
Like the 
++
operator, the return value of 
--
depends on its position relative to the
operand. When used before the operand, it decrements and returns the decremen-
ted value. When used after the operand, it decrements the operand but returns the
undecremented value. When used  after  its operand, no line  break  is allowed be-
tween the operand and the operator.
4.8.3  Bitwise Operators
The bitwise operators perform low-level manipulation of the bits in the binary repre-
sentation of numbers. Although they do not perform traditional arithmetic operations,
they  are  categorized  as  arithmetic  operators  here  because  they  operate  on  numeric
operands and return a numeric value. These operators are not commonly used in Java-
Script programming, and if you are not familiar with the binary representation of dec-
imal integers, you can probably skip this section. Four of these operators perform Boo-
lean  algebra  on the  individual  bits  of the  operands,  behaving as  if each  bit  in  each
operand were a boolean value (1=true, 0=false). The other three bitwise operators are
used to shift bits left and right.
The bitwise operators expect integer operands and behave as if those values were rep-
resented  as 32-bit  integers rather  than 64-bit  floating-point  values. These operators
convert their operands to numbers, if necessary, and then coerce the numeric values to
32-bit integers by dropping any fractional part and any bits beyond the 32nd. The shift
operators require a right-side operand between 0 and 31. After converting this operand
to an unsigned 32-bit integer, they drop any bits beyond the 5th, which yields a number
in  the  appropriate range. Surprisingly, 
NaN
Infinity
, and 
-Infinity
all convert  to  0
when used as operands of these bitwise operators.
Bitwise AND (
&
)
The 
&
operator performs a Boolean AND operation on each bit of its integer argu-
ments. A bit is set in the result only if the corresponding bit is set in both operands.
For example, 
0x1234 & 0x00FF
evaluates to 
0x0034
.
4.8  Arithmetic Expressions | 69
Core JavaScript
Bitwise OR (
|
)
The 
|
operator performs a Boolean OR operation on each bit of its integer argu-
ments. A bit is set in the result if the corresponding bit is set in one or both of the
operands. For example, 
0x1234 | 0x00FF
evaluates to 
0x12FF
.
Bitwise XOR (
^
)
The 
^
operator performs a Boolean exclusive OR operation on each bit of its integer
arguments. Exclusive OR means that either operand one is 
true
or operand two is
true
, but not both. A bit is set in this operation’s result if a corresponding bit is set
in one (but not both) of the two operands. For example, 
0xFF00 ^ 0xF0F0
evaluates
to 
0x0FF0
.
Bitwise NOT (
~
)
The 
~
operator is a unary operator that appears before its single integer operand.
It operates by reversing all bits in the operand. Because of the way signed integers
are represented in JavaScript, applying the 
~
operator to a value is equivalent to
changing  its sign and  subtracting  1.  For example 
~0x0F
evaluates to 
0xFFFFFFF0
,
or −16.
Shift left (
<<
)
The 
<<
operator moves all bits in its first operand to the left by the number of places
specified in the second operand, which should be an integer between 0 and 31. For
example, in the operation 
a << 1
, the first bit (the ones bit) of 
a
becomes the second
bit (the twos bit), the second bit of 
a
becomes the third, etc. A zero is used for the
new first bit, and the value of the 32nd bit is lost. Shifting a value left by one position
is equivalent to multiplying by 2, shifting two positions is equivalent to multiplying
by 4, and so on. For example, 
7 << 2
evaluates to 28.
Shift right with sign (
>>
)
The 
>>
operator moves all bits in its first operand  to the right by the number  of
places specified in the second operand (an integer between 0 and 31). Bits that are
shifted off the right are lost. The bits filled in on the left depend on the sign bit of
the original operand, in order to preserve the sign of the result. If the first operand
is positive, the result has zeros placed in the high bits; if the first operand is negative,
the result has ones placed in the high bits. Shifting a value right one place is equiv-
alent to dividing by 2 (discarding the remainder), shifting right two places is equiv-
alent to integer division by 4, and so on. For example, 
7 >> 1
evaluates to 3, and
−7 >> 1
evaluates to −4.
Shift right with zero fill (
>>>
)
The 
>>>
operator is just like the 
>>
operator, except that the bits shifted in on the
left are always zero, regardless of the sign of the first operand. For example, 
−1 >>
4
evaluates to −1, but 
−1 >>> 4
evaluates to 
0x0FFFFFFF
.
70 | Chapter 4: Expressions and Operators
4.9  Relational Expressions
This section describes JavaScript’s relational operators. These operators test for a re-
lationship  (such  as  “equals,”  “less than,” or “property of”)  between two values  and
return 
true
or 
false
depending on whether that relationship exists. Relational expres-
sions always evaluate  to a boolean value, and that value  is often used to control the
flow  of  program  execution  in 
if
while
 and 
for
statements  (see Chapter 5).  The
subsections that follow document the equality and inequality operators, the compari-
son operators, and JavaScript’s other two relational operators, 
in
and 
instanceof
.
4.9.1  Equality and Inequality Operators
The 
==
and 
===
operators check whether two values are the same, using two different
definitions of sameness. Both operators accept operands of any type, and both return
true
if their operands are the same and 
false
if they are different. The 
===
operator is
known as the strict equality operator (or sometimes the identity operator), and it checks
whether its two operands are “identical” using a strict definition of sameness. The 
==
operator  is  known as  the equality  operator;  it  checks  whether  its  two  operands  are
“equal” using a more relaxed definition of sameness that allows type conversions.
JavaScript supports 
=
==
, and 
===
operators. Be sure you understand the differences
between these assignment, equality, and strict equality operators, and be careful to use
the  correct  one  when  coding!  Although  it  is  tempting  to  read  all  three  operators
“equals,”  it may help to  reduce  confusion  if  you read  “gets or is assigned” for 
=
, “is
equal to” for 
==
, and “is strictly equal to” for 
===
.
The 
!=
and 
!==
operators  test  for  the  exact  opposite  of  the 
==
and 
===
operators.
The 
!=
inequality operator returns 
false
if two values are equal to each other according
to 
==
and returns 
true
otherwise. The 
!==
operator returns 
false
if two values are strictly
equal to each other and returns 
true
otherwise. As you’ll see in §4.10, the 
!
operator
computes  the  Boolean  NOT  operation.  This  makes  it  easy  to  remember  that 
!=
and 
!==
stand for “not equal to” and “not strictly equal to.”
As mentioned in §3.7, JavaScript objects are compared by reference, not by value. An
object is equal to itself, but not to any other object. If two distinct objects have the same
number of properties, with the same names and values, they are still not equal. Two
arrays that have the same elements in the same order are not equal to each other.
The  strict  equality  operator 
===
evaluates its operands,  and  then  compares  the two
values as follows, performing no type conversion:
• If the two values have different types, they are not equal.
• If both values are 
null
or both values are 
undefined
, they are equal.
• If both values are the boolean value 
true
or both are the boolean value 
false
, they
are equal.
4.9  Relational Expressions | 71
Core JavaScript
• If one or both values is 
NaN
, they are not equal. The 
NaN
value is never equal to any
other value, including itself! To check whether a value 
x
is 
NaN
, use 
x !== x
NaN
is
the only value of 
x
for which this expression will be true.
• If both values are numbers and have the same value, they are equal. If one value is
0
and the other is 
-0
, they are also equal.
• If both values are strings and contain exactly the same 16-bit values (see the sidebar
in §3.2)  in  the  same  positions,  they  are  equal.  If  the  strings  differ  in  length  or
content, they are not equal. Two strings may have the same meaning and the same
visual appearance, but still be encoded using different sequences of 16-bit values.
JavaScript  performs  no  Unicode  normalization,  and  a  pair  of  strings  like  this
are  not  considered  equal  to  the 
===
or  to  the 
==
operators.  See
String.localeCompare()
in Part III for another way to compare strings.
• If both values refer to the same object, array, or function, they are equal. If they
refer  to  different  objects  they  are  not  equal,  even if  both  objects  have identical
properties.
The equality operator 
==
is like the strict equality operator, but it is less strict.  If the
values of the two operands are not the same type, it attempts some type conversions
and tries the comparison again:
• If the two values have the same type, test them for strict equality as described above.
If they are strictly equal, they are equal. If they are not strictly equal, they are not
equal.
• If the two values do not have the same type, the 
==
operator may still consider them
equal. Use the following rules and type conversions to check for equality:
—If one value is 
null
and the other is 
undefined
, they are equal.
—If one value is a number and the other is a string, convert the string to a number
and try the comparison again, using the converted value.
—If either value is 
true
, convert it to 1 and try the comparison again. If either value
is 
false
, convert it to 0 and try the comparison again.
—If one value is an object and the other is a number or string, convert the object
to a primitive using the algorithm described in §3.8.3 and try the comparison
again. An object is converted to a primitive value by either its 
toString()
method
or  its 
valueOf()
method.  The  built-in  classes  of  core  JavaScript  attempt
valueOf()
conversion before 
toString()
conversion, except for the Date class,
which performs 
toString()
conversion. Objects that are not part of core Java-
Script may convert themselves to primitive values in an implementation-defined
way.
—Any other combinations of values are not equal.
As an example of testing for equality, consider the comparison:
"1" == true
72 | Chapter 4: Expressions and Operators
Documents you may be interested
Documents you may be interested