Relational Operators (JavaScript: 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 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.