demo

JavaScript 一共提供了8个比较运算符。

  • 大于运算符

  • < 小于运算符
  • <= 小于或等于运算符

  • = 大于或等于运算符

  • == 相等运算符
  • === 严格相等运算符
  • != 不相等运算符
  • !== 严格不相等运算符

非相等运算符

字符串按照字典顺序进行比较 'cat' > 'dog' // false '大' > '小' // false
两个运算子都是原始类型的值，则是先转成数值再比较

  1. 5 > '4' // true
  2. // 等同于 5 > Number('4')
  3. // 即 5 > 4
  5. true > false // true
  6. // 等同于 Number(true) > Number(false)
  7. // 即 1 > 0

任何值（包括NaN本身）与NaN比较，返回的都是false

  1. 1 > NaN // false
  2. 1 <= NaN // false
  3. '1' > NaN // false
  4. '1' <= NaN // false
  5. NaN > NaN // false
  6. NaN <= NaN // false

如果运算子是对象，会转为原始类型的值，再进行比较,对象转换成原始类型的值，算法是先调用valueOf方法；如果返回的还是对象，再接着调用toString方法,不会先调用toString方法

  1. var x = [2];
  2. x > '11' // true
  3. // 等同于 [2].valueOf().toString() > '11'
  4. // 即 '2' > '11'
  6. x.valueOf = function () { return '1' };
  7. x > '11' // false
  8. // 等同于 [2].valueOf() > '11'
  9. // 即 '1' > '11'
  11. { x: 2 } >= { x: 1 } // true
  12. // 等同于 { x: 2 }.valueOf().toString() >= { x: 1 }.valueOf().toString()
  13. // 即 '[object Object]' >= '[object Object]'

valueOf and toString

  1. var arr = [1,2,3,4];
  2. console.log(arr.valueOf(),arr.toString(),arr.valueOf().toString());
  3. // [ 1, 2, 3, 4 ] '1,2,3,4' '1,2,3,4'
  5. var frr = function (){
  6.     return '1,2,3,4'
  7. }
  8. console.log(frr.valueOf(),frr.toString(),frr.valueOf().toString());
  9. // [Function: frr] 'function (){\r\n    return \'1,2,3,4\'\r\n}' 'function (){\r\n    return \'1,2,3,4\'\r\n}'
  11. var orr = {
  12.     p : 1,
  13.     a : 2,
  14.     b : 3,
  15.     c : 4
  16. };
  17. console.log(orr.valueOf(),orr.toString(),orr.valueOf().toString());
  18. // { p: 1, a: 2, b: 3, c: 4 } '[object Object]' '[object Object]'

严格相等和不相等运算符

如果两个值的类型不同，直接返回false
1 === "1" // false true === "true" // false
NaN === NaN // false +0 === -0 // true

两个复合类型（对象、数组、函数）的数据比较时，不是比较它们的值是否相等，而是比较它们是否指向同一个地址

  1. {} === {} // false
  2. [] === [] // false
  3. (function () {} === function () {}) // false
  5. var v1 = {};
  6. var v2 = v1;
  7. v1 === v2 // true

undefined 和 null
undefined === undefined // true null === null // true

相等运算符

原始类型的值会转换成数值再进行比较。

  1. 1 == true // true
  2. // 等同于 1 === Number(true)
  4. 0 == false // true
  5. // 等同于 0 === Number(false)
  7. 2 == true // false
  8. // 等同于 2 === Number(true)
  10. 2 == false // false
  11. // 等同于 2 === Number(false)
  13. 'true' == true // false
  14. // 等同于 Number('true') === Number(true)
  15. // 等同于 NaN === 1
  17. '' == 0 // true
  18. // 等同于 Number('') === 0
  19. // 等同于 0 === 0
  21. '' == false  // true
  22. // 等同于 Number('') === Number(false)
  23. // 等同于 0 === 0
  25. '1' == true  // true
  26. // 等同于 Number('1') === Number(true)
  27. // 等同于 1 === 1
  29. '\n  123  \t' == 123 // true
  30. // 因为字符串转为数字时，省略前置和后置的空格

对象与原始类型值比较

  1. // 对象与数值比较时，对象转为数值
  2. [1] == 1 // true
  3. // 等同于 Number([1]) == 1
  5. // 对象与字符串比较时，对象转为字符串
  6. [1] == '1' // true
  7. // 等同于 String([1]) == '1'
  8. [1, 2] == '1,2' // true
  9. // 等同于 String([1, 2]) == '1,2'
  11. // 对象与布尔值比较时，两边都转为数值
  12. [1] == true // true
  13. // 等同于 Number([1]) == Number(true)
  14. [2] == true // false
  15. // 等同于 Number([2]) == Number(true)

undefined 和 null

  1. false == null // false
  2. false == undefined // false
  4. 0 == null // false
  5. 0 == undefined // false
  7. undefined == null // true

相等运算符的缺点

  1. 0 == ''             // true
  2. 0 == '0'            // true
  4. 2 == true           // false
  5. 2 == false          // false
  7. false == 'false'    // false
  8. false == '0'        // true
  10. false == undefined  // false
  11. false == null       // false
  12. null == undefined   // true
  14. ' \t\r\n ' == 0     // true