Javascript [Electronic resources] : The Definitive Guide (4th Edition) نسخه متنی

5.5 Relational Operators

This

section
describes the JavaScript relational operators. These are operators
that test for a relationship (such as "less-than" or
"property-of") between two values and return
true or false depending on
whether that relationship exists. As we'll see in Chapter 6, they are most commonly used in things like
if statements and while loops,
to control the flow of program execution.

5.5.1 Comparison Operators

The most


commonly used types of relational
operators are the comparison operators, which are used to determine
the relative order of two values. The comparison operators are:

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 operand; 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 both operands are numbers, or if both convert to numbers, they are
  compared numerically.
  




• If both operands are strings or convert to strings, they are compared
  as strings.
  




• If one operand is or converts to a string and one is or converts to a
  number, the operator attempts to convert the string to a number and
  perform a numerical comparison. If the string does not represent a
  number, it converts to NaN, and the comparison is
  false. (In JavaScript 1.1, the string-to-number
  conversion causes an error instead of yielding
  NaN.)
  




• If an object can be converted to either a number or a string,
  JavaScript performs the numerical conversion. This means, for
  example, that Date objects are compared numerically, and it is
  meaningful to compare two dates to see whether one is earlier than
  the other.
  




• If the operands of the comparison operators cannot both be
  successfully converted to numbers or to strings, these operators
  always return false.
  




• If either operand is or converts to NaN, the
  comparison operator always yields false.
  

Keep in mind that
string
comparison is done on a strict character-by-character basis, using
the numerical value of each character from the Unicode encoding.
Although in some cases the Unicode standard allows equivalent strings
to be encoded using different sequences of characters, the JavaScript
comparison operators do not detect these encoding differences; they
assume that all strings are expressed in normalized form. Note in
particular that string comparison is case-sensitive, and in the
Unicode encoding (at least for the ASCII subset), all capital letters
are "less than" all lowercase letters. This rule can
cause confusing results if you do not expect it. For example,
according to the < operator, the string
"Zoo" is less than the string "aardvark".

For a more robust string comparison algorithm, see the
String.localeCompare(
) method, 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( ).

The <= (less-than-or-equal) and
>= (greater-than-or-equal) operators do not
rely on the equality or identity 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 is when either operand is (or converts
to) NaN, in which case all four comparison
operators return false.

5.5.2 The in Operator

The in

operator expects a lefthand operand
that is or can be converted to a string. It expects a righthand
operand that is an object (or array). It evaluates to
true if the lefthand value is the name of a
property of the righthand object. For example:

var point = { x:1, y:1 }; // Define an object
var has_x_coord = "x" in point; // Evaluates to true
var has_y_coord = "y" in point; // Evaluates to true
var has_z_coord = "z" in point; // Evaluates to false; not a 3-D point
var ts = "toString" in point; // Inherited property; evaluates to true

5.5.3 The instanceof Operator

The instanceof


operator expects a lefthand operand that is an object and a righthand
operand that is the name of a class of objects. The operator
evaluates to true if the lefthand object is an
instance of the righthand class and evaluates to
false otherwise. We'll see in Chapter 8 that, in JavaScript, classes of objects are
defined by the constructor function that is used to initialize them.
Thus, the righthand operand of instanceof should
be the name of a constructor function. Note that all objects are
instances of Object. For example:

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

If the lefthand operand of instanceof is not an
object, or if the righthand operand is an object that is not a
constructor function, instanceof returns false. On
the other hand, it returns a runtime error if the righthand operand
is not an object at all.