完全刪除陣列中的重複項目

Question

讓我們假設我有;

var array = [1,2,3,4,4,5,5]; 

我想要它;

var newArray = [1,2,3]; 

我想完全刪除重複項，而不是將它們保留爲唯一值。有沒有辦法通過減法來實現？

Answer 1

你可以使用Array#filter與Array#indexOf和Array#lastIndexOf僅返回共享相同指數值。

var array = [1, 2, 3, 4, 4, 5, 5], 
 
    result = array.filter(function (a, _, aa) { 
 
     return aa.indexOf(a) === aa.lastIndexOf(a); 
 
    }); 
 

 
console.log(result);

Answer 2

我想它不會有一些顯着的表現，但我喜歡這個想法。

var array = [1,2,3,4,4,5,5], 
 
    res = array.reduce(function(s,a) { 
 
     if (array.filter(v => v !== a).length == array.length-1) { 
 
     s.push(a); 
 
     } 
 
     return s; 
 
    }, []); 
 
    console.log(res);

Answer 3

//Try with this code 
var arr = [1,2, 3,3,4,5,5,5,6,6]; 

arr = arr.filter(function(item, index, inputArray) { 
      return inputArray.indexOf(item) == index; 
     }); 

還應考慮這個鏈接https://fiddle.jshell.net/5hshjxvr/

Answer 4

另一種選擇是使用對象跟蹤元素使用多少次。這會破壞數組順序，但在非常大的數組上它應該快得多。

function nukeDuplications(arr) { 
 
    const hash = {}; 
 
    arr.forEach(el => { 
 
    const qty = hash[el] || 0; 
 
    hash[el] = qty+1; 
 
    }); 
 
    
 
    const ret = []; 
 
    Object.keys(hash).forEach(key => { 
 
    if (hash[key] === 1) { 
 
     ret.push(Number(key)); 
 
    } 
 
    }) 
 
    return ret; 
 
} 
 

 
var array = [1,2,3,4,4,5,5]; 
 
console.log(nukeDuplications(array));

Answer 5

稍微更有效的解決辦法是循環在陣列1的時間和在陣列上計數出現的次數中的每個值，並使用.reduce()它們存儲在一個對象，然後循環再與.filter()只返回發生一次的項目。

此方法也將保留數組的順序，因爲它僅使用對象鍵作爲引用 - 它不會遍歷它們。

var array = [1,2,3,4,4,5,5]; 
 
var valueCounts = array.reduce((result, item) => { 
 
    if (!result[item]) { 
 
     result[item] = 0; 
 
    } 
 
    result[item]++; 
 
    return result; 
 
}, {}); 
 
    
 
var unique = array.filter(function (elem) { 
 
    return !valueCounts[elem] || valueCounts[elem] <= 1; 
 
}); 
 
    
 
console.log(unique)

Answer 6

另一種選擇是使用一個對象來跟蹤一個元件被使用多少次。這會破壞數組順序，但在非常大的數組上它應該快得多。

// Both versions destroy array order. 
 

 
// ES6 version 
 
function nukeDuplications(arr) { 
 
    "use strict"; 
 
    const hash = {}; 
 
    arr.forEach(el => { 
 
    const qty = hash[el] || 0; 
 
    hash[el] = qty + 1; 
 
    }); 
 

 
    const ret = []; 
 
    Object.keys(hash).forEach(key => { 
 
    if (hash[key] === 1) { 
 
     ret.push(Number(key)); 
 
    } 
 
    }) 
 
    return ret; 
 
} 
 

 
// ES5 version 
 
function nukeDuplicationsEs5(arr) { 
 
    "use strict"; 
 
    var hash = {}; 
 
    for (var i = 0; i < arr.length; i++) { 
 
    var el = arr[i]; 
 
    var qty = hash[el] || 0; 
 
    hash[el] = qty + 1; 
 
    }; 
 

 
    var ret = []; 
 
    for (let key in hash) { 
 
    if (hash.hasOwnProperty(key)) { 
 
     if (hash[key] === 1) { 
 
      ret.push(Number(key)); 
 
     } 
 
     } 
 
    } 
 
    return ret; 
 
    } 
 

 

 
    var array = [1, 2, 3, 4, 4, 5, 5]; 
 
    console.log(nukeDuplications(array)); 
 

 
    console.log(nukeDuplicationsEs5(array));

Answer 7

有很多過於複雜，和慢跑代碼在這裏。這裏是我的解決方案：

let numbers = [1,2,3,4,4,4,4,5,5] 
let filtered = [] 

numbers.map((n) => { 
    if(numbers.indexOf(n) === numbers.lastIndexOf(n)) // If only 1 instance of n 
     filtered.push(n) 
}) 

console.log(filtered)