Section 5.5. Relational Operators

5.5. Relational Operators

This section describes the JavaScript relational operators. These operators 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 shown in Chapter 6, they are most commonly used to control the flow of program execution in structures, such as if statements and while loops.

5.5.1. Comparison Operators

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

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 performs 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 occurs 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 left-side operand that is or can be converted to a string. It expects a right-side operand that is an object (or array). 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 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 left-side operand that is an object and a right-side operand that is the name of 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. Chapter 9 shows that, in JavaScript, classes of objects are defined by the constructor function that initializes them. Thus, the right-side 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 left-side operand of instanceof is not an object, or if the right-side operand is an object that is not a constructor function, instanceof returns false. However, it returns a runtime error if the right-side operand is not an object at all.