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;
}