数组去重-简单数组，复杂数组

简单数组去重：

方法1：准备一个空数组res，如果res里面有arr的数据，就不添加到res里面了，如果res里面没有，就添加到res里面

var arr = [1, 2, 3, 2, 1, 2, 10, 3, 5, 4, 3, 2, 3, 4, 2, 1, 10]
var res = []
for (var i = 0; i < arr.length; i++) {
    if (res.indexOf(arr[i]) === -1) {
        res.push(arr[i])
    }
}
console.log(res)

方法2：遍历原始数据，arr[i]是数组中的每一个，从i+1向后开始检索，如果存在和arr[i]一样的数据，就把arr[i]删掉

var arr = [1, 2, 3, 2, 1, 2, 10, 3, 5, 4, 3, 2, 3, 4, 2, 1, 10]
for (var i = 0; i < arr.length; i++) {
    var index = arr.indexOf(arr[i], i + 1)
    if (index !== -1) {
        arr.splice(index, 1)
        i--
    }
}
console.log(arr);

方法3：还是遍历原数组，用arr[i]和i+1后面的数据比较，一样就删除，删除之后重新比较，就不用担心数组塌陷的问题了，因为是重新比较的

var arr = [1, 2, 3, 2, 1, 2, 10, 3, 5, 4, 3, 2, 3, 4, 2, 1, 10]
for (var i = 0; i < arr.length; i++) {
    var index = arr.indexOf(arr[i], i + 1)
    // 用while循环，和if不一样的是，if是复合条件执行一次，while是只要复合条件就一直执行，直到不符合条件为止
    while (index !== -1) {
        arr.splice(index, 1)
        // 删除完之后，重新将arr[i]和i+1后面的数据进行比较
        index = arr.indexOf(arr[i], i + 1)
    }
}
console.log(arr)

方法4：利用对象的key值不重名，把数组内的每一项当做key值使用(只适合数字数组)

var arr = [1, 2, 3, 2, 1, 2, 10, 3, 5, 4, 3, 2, 3, 4, 2, 1, 10]
// 准备一个空对象
var obj = {}
for (var i = 0; i < arr.length; i++) {
    // 把arr[i]当做obj的key值使用，因为涉及到变量和纯数字的关系，必须用数组关联语法
    obj[arr[i]] = '随便写点'
}
// 准备一个空数组
var res = []
for (var k in obj) {
    // k-0 是强制数据类型转换，因为出来的结果是每一项是字符串，如果想让每一项是数字，可以用k-0
    res.push(k - 0)
}
console.log(res)

// 简化：
var obj = {}
var res = []
for (var i = 0; i < arr.length; i++) obj[arr[i]] = '随便'
for (var k in obj) res.push(k)
console.log(res)

方法5：利用一个叫做Set的数据结构，Set数据结构是和数组差不多的数据类型，但是有一个天生的特质就是不接受重复的数据
语法：var s=new Set(数组)

var arr = [1, 2, 3, 2, 1, 2, 10, 3, 5, 4, 3, 2, 3, 4, 2, 1, 10]
var s=new Set(arr)
console.log(s) //得到的数据没有重复的数据，但是不是数组类型

// 需要把s转换成数组
方法1：
// 用Array.from()把数据转换成数组
var res=Array.from(s)
console.log(res)
// 简写
var res1=Array.from(new Set(arr))
console.log(res1)

方法2：
// 用展开运算符 `...` ，作用是把该数据类型展开, 里面的内容一个一个的拿出来
var res2=[...s]
console.log(res2)

复杂数组去重：

方法1：利用new Set()不接受重复数据

const arr = [
      { id: 1, name: 'ryuto' },
      { id: 2, name: 'yuta' },
      { id: 1, name: 'ryuto' }
];

var arrNew = [...new Set(arr.map(item => JSON.stringify(item)))].map(item => JSON.parse(item))
console.log('arrNew', arrNew);

方法2：利用reduce叠加，reduce的第一个参数是一个函数，第二个参数是初始值，函数的第一个参数是初始值，第二次是叠加的结果

const arr = [
    { id: 1, name: 'ryuto' },
    { id: 2, name: 'yuta' },
    { id: 1, name: 'ryuto' }
];

const arrNew = arr.reduce((prev, item) => {
    var exist = prev.find(i => i.id === item.id)
    if (!exist) {	
        prev.push(item)
    }
    return prev
}, [])
console.log('arrNew', arrNew);

方法3：使用filter和findIndex方法

const arr = [
    { id: 1, name: 'ryuto' },
    { id: 2, name: 'yuta' },
    { id: 1, name: 'ryuto' }
];
const arrNew = arr.filter((item, index) => {
    return arr.findIndex(obj => obj.id === item.id) === index;
});
console.log('arrNew', arrNew);