去重这个词，在我们程序员的日常中还是很常见的，字符串、数组、对象、嵌套形式的去重，各种去重应用场景，最近有空整理整理各种数据的去重方法,这里整理的都是按照常规的数据，特殊的先不考虑，主要是看处理方法和思路。

一、字符串去重

1.indexOf 方法

const str = 'asdfasd'
const ChangeStr = (data) => {
  let newstr = ''
  for(i in data){
    if(i==data.indexOf(data[i])){
     //for循环遍历，判断当前值是否等于当前下标
    //indexOf方法返回第一个查找元素下标
    //注意：for循环的 i 类型都是string,所以不要用严格等于判断
      newstr += data[i]
    }
  }
  return newstr
}
//if()里的条件判断，判断data和newstr都可以
console.log(ChangeStr(str))
// "asdf"

2.search 方法

const str = 'asdfasd'
const ChangeStr = (data) => {
  let newstr = ''
  for(i in data){
    if(i==data.search(data[i])){
   //indexOf与search方法一样，获取元素下标，没有返回-1
      newstr += data[i]
    }
  }
  return newstr
}
//if()里的条件判断，判断data和newstr都可以
console.log(ChangeStr(str))
// "asdf"

3.includes 方法

const str = 'asdfasd'
const ChangeStr = (data) => {
  let newstr = ''
  for(i in data){
    if(!newstr.includes(data[i])){
    //es6的新语法，过程是严格判断
      newstr += data[i]
    }
  }
  return newstr
}
console.log(ChangeStr(str),'ChangeStr')
// "asdf"

4.Set 方法

 const str = 'asdfasd'
 const ChangeStr = ( data ) =>  [... new Set(data)].join('')
 //用es6的Set去重，转成数组，再转字符串
 console.log( ChangeStr( str ), 'ChangeStr' )
// "asdf"

这里双重for循环就不讲了，循环用少用，耗性能。

二、数组去重 string | number [ ]

1.indexOf 方法

const data = [ 1, 2, 2, 4, 5, 4 ]
const ChangeArr = ( data ) => {
  const newarr = []
  data.map( ( item, index ) => {
    if ( data.indexOf( item ) === index ) {
      newarr.push( item )
    }
    //判断当前下标与元素下标是否一致，一致说明是唯一的
    //可以判断newarr是否存在该值
  } )
  return newarr
}
console.log( ChangeArr( data ), 'ChangeArr' )
// [1, 2, 4, 5]

2.sort 方法

const data = [ 1, 2, 2, 4, 5, 4 ]
const ChangeArr = ( data ) => {
  const newarr = []
  data.map( ( item, index ) => {
    if ( data.indexOf( item ) === index ) {
      newarr.push( item )
    }
    //先排序然后判断当前下标与元素下标是否一致，一致说明是唯一的
  } )
  return newarr
}
console.log( ChangeArr( data ), 'ChangeArr' )
// [1, 2, 4, 5]

3.includes 方法

const data = [ 1, 2, 2, 4, 5, 4 ]
const ChangeArr = ( data ) => {
  const newarr = []
  for ( let i = 0; i < data.length; i++ ) {
    // if(newarr.indexOf(data[i])===-1){
    //for每个值，用下标判断新数组存不存在
    if ( !newarr.includes( data[ i ] ) ) {
      //用es6新语法includes判断是否存在
      newarr.push( data[ i ] )
    }
  }
  return newarr
}
console.log( ChangeArr( data ), 'ChangeArr' )
// [1, 2, 4, 5]

4.Set 方法

const data = [ 1, 2, 2, 4, 5, 4 ]
const ChangeArr = ( data ) => {
  return Array.from( new Set( data ) )
  // es6的Set方法去重
  return [...new Set(data)]
  // es6的Set和数组解构赋值，该方法可用与字符串去重
}
console.log( ChangeArr( data ), 'ChangeArr' )
// [1, 2, 4, 5]

三、对象去重

对象里不会存在一样的属性名，每个属性对应一块固定内存

最终创建结果就是，后面的覆盖前面的，对象的去重，主要就是Object.keys()和Object.values()转成数组，然后跟数组一样去重，以及hasOwnProperty的运用。

1.Object+includes

//应用场景，添加了多个值，把对象里值相同的去重
const data = {col: 4,col1: 5,col2: 6,col3: 4,col5: 5}
const ChangeObj = (data) => {
  const newobj = {}
  Object.keys( data ).map( ( item ) => {
    if ( !Object.values( newobj ).includes( data[ item ] ) ) {
      newobj[ item ] = data[ item ]
    }
  } )
  return newobj
}

console.log( ChangeObj( data ), 'ChangeObj' )
// {col: 4, col1: 5, col2: 6}

四、嵌套式复杂去重

1.forEach 合并数组内name重复的对象

要求数组中的对象，拥有同样name的，把数据去重合并到一个对象里

const data = [ {
  name: '小明',
  hobbies: '跳舞'
}, {
  name: '小红',
  hobbies: '唱歌'
}, {
  name: '小明',
  hobbies: '打球'
}, {
  name: '小明',
  hobbies: '滑雪'
}, {
  name: '小红',
  hobbies: '打人'
}, {
  name: '小东',
  hobbies: '吹气球'
} ]
const ChangeArr = ( data ) => {
  const newobj = {}
  if ( data && data.length > 0 ) {
    data.forEach( ( k ) => {
      if ( newobj[ k.name ] ) {
        newobj[ k.name ] =
          newobj[ k.name ] + ' | ' + k.hobbies
      } else {
        newobj[ k.name ] = k.hobbies
      }
    } )
  }
  return newobj
}
console.log( ChangeArr( data ), 'ChangeArr' )
// {小明: "跳舞 | 打球 | 滑雪", 小红: "唱歌 | 打人", 小东: "吹气球"}

2.对象数组根据对象的某key值去重

const data = [ {
  id: 1,
  name: '111'
}, {
  id: 2,
  name: '222'
}, {
  id: 3,
  name: '333'
}, {
  id: 1,
  name: '444'
}, {
  id: 2,
  name: '555'
} ]
const ChangeArr = ( data ) => {
  const newobj = {}
  if ( data && data.length > 0 ) {
    data.forEach( ( item ) => {
      newobj[ item.id ] = item
    } )
  }
  return newobj
}
console.log( ChangeArr( data ), 'ChangeArr' )
// { 1: {id: 1, name: "444"} ,2: {id: 2, name: "555"},3: {id: 3, name: "333"} }

3.格式一致的对象数组去重

//JSON.stringify转成字符串，就可以去重了，前提是数据格式是严格
const data =[{name:1,age:1},{name:2,age:2},{name:1,age:1},{name:2,age:2}]
const ChangeArr = (data) => {
  const newdata = data.map(item => (JSON.stringify(item)))
  return [...new Set(newdata)]
}
console.log(ChangeArr(data))
// ["{"name":1,"age":1}", "{"name":2,"age":2}"]

4.多维数组去重

方法一 正常递归方法

const data = [1,[2,3],[3,2,[1,6,[3,5,'3']]]]
const allarr = new Set() //直接创建一个Set数据，后面去重用
const ChangeArr = (array)=>{
  var len = array.length
  for (var i = 0; i < len ;i ++) {
    if (typeof array[i] == 'object') { // 如若数组元素类型是object，则递归
      ChangeArr(array[i])
    } else {
      allarr.add(array[i]) // 否则添加到allarr数组中
    }
  }
}
console.log(ChangeArr(data))
console.log([...allarr],'11111')
// [1, 2, 3, 6, 5, "3"] "11111"

方法二

arr.flat（）数组的新方法，自动将维度

const data = [1,[2,3],[3,2,[1,6,[3,5,'3']]]]
const ChangeArr = (array)=>{
  return  [...new Set(data.flat(Infinity))]
}

console.log(ChangeArr(data))

更多数据格式去重后期追加，有复杂格式的去重需求，评论区留下数据格式