利用hasOwnProperty给数组去重的面试题分享

hasOwnProperty

hasOwnProperty是javascript中用于检测对象是否包含某个属性的方法，返回一个布尔值。

var o = { a: 1};
console.log(o.hasOwnProperty('a')); // true
console.log(o.hasOwnProperty('b')); // false

有一个用hasOwnProperty实现数组去重的方法：

var arr = ['a', 'b', 'c', 'b'];

function uniqueArr(arr){

var unique = [], temp = {};

for(var i = 0; i < arr.length; i++){
 if(temp[arr[i]] === undefined){
  temp[arr[i]] = 1;
  unique.push(arr[i]);
 }
}

return unique;
}

但是，如果数组中包含引用类型的指，则此方法失效。 那么该如何判断两个对象是否相等呢？

我们假设，如果两个对象具有相同的keys，并且每个key对应的value也都相等，则这两个对象相等。

现在我们已经明确了判断规则，那么该如何实现呢？

var o1 = {a:1, b:2},
o2 = {b:2, a:1},
o3 = {a:2, b:1};

function isEqual(o1, o2){

var o1_keys = Object.keys(o1);
var o2_keys = Object.keys(o1);

if(o1_keys.length !== o2_keys.length){
 return false;
}

o1_keys = o1_keys.sort();
o2_keys = o2_keys.sort();
if(o1_keys.join('||') !== o2_keys.join('||')){
 return false;
}

var r = true;
for(var key of o1_keys){

if( !isPrimitive(o1[key] ) && !isPrimitive( o2[key])){
  if(!isEqual(o1[key], o2[key])){
  r = false;
  break;
  }
 } else if(o1[key] !== o2[key]){
  r = false;
  break;
 }
}

return r;

function isPrimitive(v){
 var type = typeof v;
 return type === 'number' || type === 'string' || type === 'boolean' || v === undefined || v === null;
}

}

console.log(isEqual(o1, o2));
console.log(isEqual(o1, o3));
console.log(isEqual({a:1, b:{c:1}}, {b:{c:2}, a:1}));
console.log(isEqual({a:1, b:{c:1}}, {b:{c:1}, a:1}));
console.log(isEqual({a:1, b:{c:1},c:2}, {b:{c:1}, a:1}));
console.log(isEqual({a:1, b:{c:1}}, {b:{c:1}, a:{b:1}}));
console.log(isEqual({a:1, b:function(){}}, {b:function(){}, a:1}));

上面的代码，我们基本上实现了判断两个对象是否相等，but！！！，还有一点，就是如果对象是函数，怎么判断是否相等？简单一点：Object.toString。

var f1 = function(){};
var f2 = function(){};

if(f1.toString() === f2.toString()){
console.log(true);
}

来源：https://segmentfault.com/a/1190000016909382