# 比较运算符
# 比较运算符汇总
>大于运算符<小于运算符<=小于或等于运算符>=大于或等于运算符==相等运算符===严格相等运算符!=不相等运算符!==严格不相等运算符
# 非相等比较
# 1. 字符串类型比较
字符串按照字典顺序进行比较。
'cat' > 'dog' // false
'cat' > 'catalog' // false
1
2
2
JavaScript 引擎内部首先比较首字符的 Unicode 码点。如果相等，再比较第二个字符的 Unicode 码点，以此类推。
var str = '天气';
alert( str.charCodeAt(0) );
//22825
alert( String.fromCharCode(22825, 27668) );
//天气
1
2
3
4
5
6
2
3
4
5
6
以上是字符串和Unicode编码互相转换的方式。
# 2. 原始数据类型比较
如果两个运算子都是原始类型的值，则是先转成数值再比较。
5 > '4' // true
// 等同于 5 > Number('4')
// 即 5 > 4
true > false // true
// 等同于 Number(true) > Number(false)
// 即 1 > 0
2 > true // true
// 等同于 2 > Number(true)
// 即 2 > 1
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
这里需要注意与NaN的比较。任何值（包括NaN本身）与NaN比较，返回的都是false。
1 > NaN // false
1 <= NaN // false
'1' > NaN // false
'1' <= NaN // false
NaN > NaN // false
NaN <= NaN // false
1
2
3
4
5
6
2
3
4
5
6
# 3. 复合数据类型（对象）比较
对象转换成原始类型的值，算法是先调用valueOf方法；如果返回的还是对象，再接着调用toString方法。
var x = [2];
x > '11' // true
// 等同于 [2].valueOf().toString() > '11'
// 即 '2' > '11'
x.valueOf = function () { return '1' };
x > '11' // false
// 等同于 [2].valueOf() > '11'
// 即 '1' > '11'
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
[2] > [1] // true
// 等同于 [2].valueOf().toString() > [1].valueOf().toString()
// 即 '2' > '1'
[2] > [11] // true
// 等同于 [2].valueOf().toString() > [11].valueOf().toString()
// 即 '2' > '11'
{ x: 2 } >= { x: 1 } // true
// 等同于 { x: 2 }.valueOf().toString() >= { x: 1 }.valueOf().toString()
// 即 '[object Object]' >= '[object Object]'
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
# 相等（严格）比较
# 1. 严格相等
如果两个值的类型不同，直接返回false。
1 === "1" // false
true === "true" // false
1
2
2
同一类型的原始类型的值（数值、字符串、布尔值）比较时，值相同就返回true，值不同就返回false。
1 === 0x1 // true
1
NaN与任何值都不相等（包括自身）。另外，正0等于负0。
NaN === NaN // false
+0 === -0 // true
1
2
2
两个复合类型（对象、数组、函数）的数据比较时，不是比较它们的值是否相等，而是比较它们是否指向同一个地址。
{} === {} // false
[] === [] // false
(function () {} === function () {}) // false
1
2
3
2
3
对于两个对象的比较，严格相等运算符比较的是地址，而大于或小于运算符比较的是值。
var v1 = {};
var v2 = v1;
v1 === v2 // true
var obj1 = {};
var obj2 = {};
obj1 > obj2 // false
obj1 < obj2 // false
obj1 === obj2 // false
1
2
3
4
5
6
7
8
9
10
2
3
4
5
6
7
8
9
10
undefined和null与自身严格相等。
undefined === undefined // true
null === null // true
1
2
2
var v1;
var v2;
v1 === v2 // true
1
2
3
2
3
# 2. 严格不相等
严格相等运算符有一个对应的“严格不相等运算符”（!==），它的算法就是先求严格相等运算符的结果，然后返回相反值。
1 !== '1' // true
// 等同于
!(1 === '1')
1
2
3
2
3