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