javascript

Chapter 3: Language Basics
❑
❑
❑
If one operand is a number, convert the other operand to a number and perform a numeric
comparison.
If an operand is an object, call valueOf() and use its result to perform the comparison
according to the previous rules. If valueOf() is not available, call toString() and use that
value according to the previous rules.
If an operand is a Boolean, convert it to a number and perform the comparison.
When a relational operator is used on two strings, an interesting behavior occurs. Many expect that less -
than means “ alphabetically before ” and greater - than means “ alphabetically after, ” but this is not the
case. For strings, each of the first string ’ s character codes is numerically compared against the character
codes in a corresponding location in the second string. After this comparison is complete, a Boolean
value is returned. The problem here is that the character codes of uppercase letters are all lower than the
character codes of lowercase letters, meaning that you can run into situations like this:
var result = “Brick” < “alphabet”; //true
In this example, the string “Brick” is considered to be less than the string “alphabet” because the
letter B has a character code of 66 and the letter a has a character code of 97. To force a true alphabetic
result, you must convert both operands into a common case (upper or lower) and then compare like this:
var result = “Brick”.toLowerCase() < “alphabet”.toLowerCase(); //false
Converting both operands to lowercase ensures that “alphabet” is correctly identified as alphabetically
before “Brick” .
Another sticky situation occurs when comparing numbers that are strings, such as in this example:
var result = “23” < “3”; //true
This code returns true when comparing the string “23” to “3” . Because both operands are strings, they
are compared by their character codes (the character code for “2” is 50; the character code for “3” is 51).
If, however, one of the operands is changed to a number as in the following example, the result makes
more sense:
var result = “23” < 3;
//false
Here, the string “23” is converted into the number 23 and then compared to 3, giving the expected
result. Whenever a number is compared to a string, the string is converted into a number and then
numerically compared to the other number. This works well for cases like the previous example, but
what if the string can ’ t be converted into a number? Consider this example:
var result = “a” < 3;
//false because “a” becomes NaN
The letter “a” can ’ t be meaningfully converted into a number, so it becomes NaN . As a rule, the result of
any relational operation with NaN is false , which is interesting when considering the following:
var result1 = NaN < 3;
var result2 = NaN > = 3;
//false
//false
59