js去除数组重复成员

js去除数组重复成员

第一种思路是：遍历要删除的数组arr, 把元素分别放入另一个数组tmp中，在判断该元素在arr中不存在才允许放入tmp中

用到两个函数：for ...in 和 indexOf()

  <script type="text/javascript">
 var student = ['qiang','ming','tao','li','liang','you','qiang','tao'];
  function unique(arr){
  // 遍历arr，把元素分别放入tmp数组(不存在才放)
  var tmp = new Array();
  for(var i in arr){
  //该元素在tmp内部不存在才允许追加
  if(tmp.indexOf(arr[i])==-1){
  tmp.push(arr[i]);
  }
 }
  return tmp;
  }
  </script>

第二种思路是：把目标数组arr的元素值和键的位置调换 自动就把重复的元素给删除掉了，调换后的样子：array('qiang'=>1,'ming'=>1,'tao'=>1)

  <script type="text/javascript">
  var student = ['qiang','ming','tao','li','liang','you','qiang','tao'];
  function unique(arr){
  var tmp = new Array();
  for(var m in arr){
  tmp[arr[m]]=1;
  }
  //再把键和值的位置再次调换
  var tmparr = new Array();
  for(var n in tmp){
  tmparr.push(n);
  }
  return tmparr;
  }
  </script>

第三种思路是：ES6 提供了新的数据结构 Set。它类似于数组，但是成员的值都是唯一的，没有重复的值。使用Array.from方法可以将Set结构转为数组的特性,去除数组重复成员

 let oldarray = [1,2,3,4,4,5]
 function RemovingArrayRepeating(array) {
   return Array.from(new Set(array));
 }
 RemovingArrayRepeating(oldarray )//[1,2,3,4,5]

第四种思路是：利用hasOwnProperty

 function unique(arr) {
 var obj = {};
             return arr.filter(function (item, index, arr) {
                 return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)//利用hasOwnProperty 判断是否存在对象属性 但是无法判断对象是否相同,直接去重
             })
 }

第五种思路是：利用Map数据结构去重

 function unique(arr) {
 let map = new Map();
             let array = new Array();
             // 数组用于返回结果
             for (let i = 0; i < arr.length; i++) {
                 if (map.has(arr[i])) {
                     // 如果有该key值
                     map.set(arr[i], true);
                 } else {
                     map.set(arr[i], false);
                     // 如果没有该key值
                     array.push(arr[i]);
                 }
             }
             return array;//对象不能去重
 }

第六种思路是：利用reduce+includes

 function unique(arr) {
 return arr.reduce((prev, cur) => prev.includes(cur) ? prev : [...prev, cur], []);//对象不能去重
 }

第七种思路是：利用filter

 function unique(arr) {
 return arr.filter(
                 function (item, index, arr) {
                     //当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素
                     return arr.indexOf(item, 0) === index;//直接把NaN干掉
                 }
             );
 }

第八种思路是：利用includes

 function unique(arr) {
 if (!Array.isArray(arr)) {
                 console.log('type error!')
                 return
             }
             var array = []; for (var i = 0; i < arr.length; i++) {
                 if (!array.includes(arr[i])) {
                     //includes 检测数组是否有某个值
                     array.push(arr[i]);
                 }

             }
             return array;//对象不能去重
 }

第九种思路是：利用sort()

 function unique(arr) {
 if (!Array.isArray(arr)) {
                 console.log('type error!')
                 return
             }
             arr = arr.sort()
             var arrry = [arr[0]];
             for (
                 var i = 1; i < arr.length; i++) {
                 if (arr[i] !== arr[i - 1]) {
                     arrry.push(arr[i]);
                 }
             }
             return arrry;//NaN 对象不能去重
 }

第十种思路是：利用对象的属性不能相同的特点进行去重

 function unique(arr) {
     var arrry = [];
             var obj = {};
             for (var i = 0; i < arr.length; i++) {
                 if (!obj[arr[i]]) {
                     arrry.push(arr[i])
                     obj[arr[i]] = 1
                 } else {
                     obj[arr[i]]++
                 }
             }
             return arrry;////'NaN' true 对象不能去重
 }

第十一种思路是：js根据某字段去重json数组

    /**
  * 根据某一字段 去重json数组
  * @param JsonArray ：需要去重的json数组
  * @param fieldName ：根据此字段去重
  */
 export function jsonArrayToFilterByFieldName(JsonArray, fieldName) {
   let deduplicateJsonArray = [];
   for (let i = 0; i < JsonArray.length; i++) {
       let retrieveJson = JsonArray[i];
       if (i == 0) {
         deduplicateJsonArray.push(retrieveJson);
       } else {
           let filterData = deduplicateJsonArray.filter(function (item) {
               return item[fieldName] == retrieveJson[fieldName];
           })
           if (filterData.length == 0) {
             deduplicateJsonArray.push(retrieveJson);
           }
       }
   }
   return deduplicateJsonArray;
 }