检验空数组和空对象以及两个数组比较，去重

1.通过JSON自带的stringify()方法来判断

function isEmptyObj(obj) {
    return JSON.stringify(obj) === '{}'
}
console.log('对象是否为空：', isEmptyObj({}))

2.for in 循环判断

function isEmptyObj(obj) {
    for(let item in obj) {
        return true
    }
    return false
}    
console.log('对象是否为空：', isEmptyObj({}))

3.使用ES6的Object.keys()方法

function isEmptyObj(obj) {
    return Object.keys(obj).length === 0
}
console.log('对象是否为空：', isEmptyObj({}))

4.Object.getOwnPropertyNames()方法

function isEmptyObj(obj) {
    return Object.getOwnPropertyNames(obj).length === 0
} 
console.log('对象是否为空：', isEmptyObj({}))

判断数组

数组是属于Object类型的，也就是引用类型，所以不能使用typeof判断其具体类型

	let arr = []
	console.log(arr instanceof Array)	//true

instanceof 运算符 ， 主要是判断某个实例（arr）是否属于某个对象

	let arr = []
	console.log(arr instanceof Array)	//true

let arr = []
	console.log(Array.isArray(arr))	//true

Object.getPrototypeOf() 方法返回指定对象的原型，然后和Array的原型对比

	let arr = []
	console.log(Object.getPrototypeOf(arr) == Array.prototype)	//true

Array原型链上的isPrototypeof
Array.prototype表示Array的构造函数的原型
isPrototypeof()方法可以判断一个对象是否存在另一个对象的原型链上

	let arr = []
	console.log(Array.prototype.isPrototypeof(arr))	//true

两个数组进行比较，不同的放入一个数组中

const a = [1,2,3,4]
const b = [1, 3]
const c = a.filter(v => b.findIndex(el => el === v) === -1);
console.log(c) // [2, 4]

去重

 removeDuplicateObj(arr){
    let newArr = []
    let obj = {};
    for (var i = 0; i < arr.length; i++) {
      if (!obj[arr[i].eid]) {
        newArr.push(arr[i]);
        obj[arr[i].eid] = true;
      }
    }
    return newArr
  },

两个数组比较

请在两个对象数组中找到其中一个与另一不重复的对象。然后追加到另一个数组中。比如在数组1[{a:1},{a:2},{a:3},{a:5}]与数组2[{a:1},{a:2},{a:4}]中找到数组1中不与数组2重复的对象{a:3}和{a:5}，最后得到的数组2为[{a:1},{a:2},{a:4},{a:3},{a:5}]。

    var arr1 =[{a:1},{a:2},{a:3},{a:5}];
    var arr2 =[{a:1},{a:2},{a:4}];
    arr1.map((item1)=>{
        arr2.map((item2)=>{
            if(item1.a == item2.a){
                //添加属性用来标记相同的对象
                item1.isRepeat = true;
            }
        })
    });
    arr1.map((item)=>{
        //通过标记筛选对象
        if(!item.isRepeat){
            arr2.push(item);
        }
    });
   console.log(arr2);//[{a:1},{a:2},{a:4},{a:3},{a:5}];

思路：直接轮循两个数组,取出不包含数组2元素的数组1，然后将数组1合并到数组2。

    var arr1 =[{a:1},{a:2},{a:3},{a:5}];
    var arr2 =[{a:1},{a:2},{a:4}];
    for (var i = 0; i < arr2.length; i++) {
        for (var j = 0; j < arr1.length; j++) {
            if (arr2[i].a == arr1[j].a) {
                arr1.splice(j, 1);
            }
        }
    }
    arr2 = arr2.concat(arr1);
    console.log(arr2);//[{a:1},{a:2},{a:4},{a:3},{a:5}]

思路：将两个数组合并,然后两层循坏。

    var arr1 =[{a:1},{a:2},{a:3},{a:5}];
    var arr2 =[{a:1},{a:2},{a:4}];
    //将arr1与arr2合并。
    arr2 = arr2.concat(arr1);
    for (var i = 0; i < arr2.length; i++) {
        for (var j = i+1; j < arr2.length; j++) {
            if (arr2[i].a == arr2[j].a) {
                arr2.splice(j, 1);
            }
        }
    }
    console.log(arr2);//[{a:1},{a:2},{a:4},{a:3},{a:5}]