基本类型的两种特殊情况

  • 判断 +0 与 -0
  1. +0 === -0; // true

由于 js 表示数字使用的是 IEEE_754 浮点数表示法，最高位是符号位(0代表正，1代表负)，则1000（-0）和0000（0）表示的都是0。所有才有正负区别。

  1. 1 / +0 === 1 / -0 // false
  • 判断 NaN
  1. NaN === NaN; // false

利用 NaN 与自身不相等的特性可以判断相等性。

  1. function eq(a, b) {
  2.     if (a !== a) return b !== b;
  3. }

复杂类型

  • String

'' + a === '' + b

  • Boolean

+a === +b

  • Number

+a === +b ，需注意NaN这种特殊情况。

  • Date

+a === +b

  • RegExp

'' + a === '' + b

  • Function
    • '' + a === '' + b
    • 指向不同引用则认为不相等
  • Array
    • 递归遍历，需要注意循环引用的问题
  • Object
    • 递归遍历，同时也要注意循环引用的问题

总结：

  1. 利用隐式类型转换进行对比。
  2. 递归遍历。

参考实现

  1. var toString = Object.prototype.toString;
  3. function isFunction(obj) {
  4.     return toString.call(obj) === '[object Function]'
  5. }
  7. function eq(a, b, aStack, bStack) {
  9.     // === 结果为 true 的区别出 +0 和 -0
  10.     if (a === b) return a !== 0 || 1 / a === 1 / b;
  12.     // typeof null 的结果为 object ，这里做判断，是为了让有 null 的情况尽早退出函数
  13.     if (a == null || b == null) return false;
  15.     // 判断 NaN
  16.     if (a !== a) return b !== b;
  18.     // 判断参数 a 类型，如果是基本类型，在这里可以直接返回 false
  19.     var type = typeof a;
  20.     if (type !== 'function' && type !== 'object' && typeof b != 'object') return false;
  22.     // 更复杂的对象使用 deepEq 函数进行深度比较
  23.     return deepEq(a, b, aStack, bStack);
  24. };
  26. function deepEq(a, b, aStack, bStack) {
  28.     // a 和 b 的内部属性 [[class]] 相同时 返回 true
  29.     var className = toString.call(a);
  30.     if (className !== toString.call(b)) return false;
  32.     switch (className) {
  33.         case '[object RegExp]':
  34.         case '[object String]':
  35.             return '' + a === '' + b;
  36.         case '[object Number]':
  37.             if (+a !== +a) return +b !== +b;
  38.             return +a === 0 ? 1 / +a === 1 / b : +a === +b;
  39.         case '[object Date]':
  40.         case '[object Boolean]':
  41.             return +a === +b;
  42.     }
  44.     var areArrays = className === '[object Array]';
  45.     // 不是数组
  46.     if (!areArrays) {
  47.         // 过滤掉两个函数的情况
  48.         if (typeof a != 'object' || typeof b != 'object') return false;
  50.         var aCtor = a.constructor,
  51.             bCtor = b.constructor;
  52.         // aCtor 和 bCtor 必须都存在并且都不是 Object 构造函数的情况下，aCtor 不等于 bCtor， 那这两个对象就真的不相等啦
  53.         if (aCtor !== bCtor && !(isFunction(aCtor) && aCtor instanceof aCtor && isFunction(bCtor) && bCtor instanceof bCtor) && ('constructor' in a && 'constructor' in b)) {
  54.             return false;
  55.         }
  56.     }
  59.     aStack = aStack || [];
  60.     bStack = bStack || [];
  61.     var length = aStack.length;
  63.     // 检查是否有循环引用的部分
  64.     while (length--) {
  65.         if (aStack[length] === a) {
  66.             return bStack[length] === b;
  67.         }
  68.     }
  70.     aStack.push(a);
  71.     bStack.push(b);
  73.     // 数组判断
  74.     if (areArrays) {
  76.         length = a.length;
  77.         if (length !== b.length) return false;
  79.         while (length--) {
  80.             if (!eq(a[length], b[length], aStack, bStack)) return false;
  81.         }
  82.     }
  83.     // 对象判断
  84.     else {
  86.         var keys = Object.keys(a),
  87.             key;
  88.         length = keys.length;
  90.         if (Object.keys(b).length !== length) return false;
  91.         while (length--) {
  93.             key = keys[length];
  94.             if (!(b.hasOwnProperty(key) && eq(a[key], b[key], aStack, bStack))) return false;
  95.         }
  96.     }
  98.     aStack.pop();
  99.     bStack.pop();
  100.     return true;
  102. }
  104. console.log(eq(0, 0)) // true
  105. console.log(eq(0, -0)) // false
  107. console.log(eq(NaN, NaN)); // true
  108. console.log(eq(Number(NaN), Number(NaN))); // true
  110. console.log(eq('Curly', new String('Curly'))); // true
  112. console.log(eq([1], [1])); // true
  113. console.log(eq({ value: 1 }, { value: 1 })); // true
  115. var a, b;
  117. a = { foo: { b: { foo: { c: { foo: null } } } } };
  118. b = { foo: { b: { foo: { c: { foo: null } } } } };
  119. a.foo.b.foo.c.foo = a;
  120. b.foo.b.foo.c.foo = b;
  122. console.log(eq(a, b)) // true

参考资料