Удалить повторяющиеся значения из массива JS
У меня есть очень простой массив JavaScript, который может содержать или не содержать дубликаты.
var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];
Мне нужно удалить дубликаты и поместить уникальные значения в новый массив.
Я мог бы указать на все коды, которые я пробовал, но я думаю, что это бесполезно, потому что они не работают. Я тоже принимаю решения jQuery.
Подобный вопрос:
54 ответа
https://jsfiddle.net/2w0k5tz8/
function remove_duplicates(array_){
var ret_array = new Array();
for (var a = array_.length - 1; a >= 0; a--) {
for (var b = array_.length - 1; b >= 0; b--) {
if(array_[a] == array_[b] && a != b){
delete array_[b];
}
};
if(array_[a] != undefined)
ret_array.push(array_[a]);
};
return ret_array;
}
console.log(remove_duplicates(Array(1,1,1,2,2,2,3,3,3)));
Выполните цикл, удалите дубликаты и создайте заполнитель массива клонов, потому что индекс массива не будет обновляться.
Цикл в обратном направлении для лучшей производительности (ваш цикл не должен постоянно проверять длину вашего массива)
Для тех, кто хочет объединить массивы с дублирующимися элементами в один уникальный массив:
function flattenUniq(arrays) {
var args = Array.prototype.slice.call(arguments);
var array = [].concat.apply([], args)
var result = array.reduce(function(prev, curr){
if (prev.indexOf(curr) < 0) prev.push(curr);
return prev;
},[]);
return result;
}
Это, вероятно, один из самых быстрых способов постоянного удаления дубликатов из массива в10 раз быстрее, чем большинство функций здесь. И в 78 раз быстрее в сафари.
function toUnique(a,b,c){ //array,placeholder,placeholder
b=a.length;while(c=--b)while(c--)a[b]!==a[c]||a.splice(c,1)
}
- Тест: http://jsperf.com/wgu
- Демо: http://jsfiddle.net/46S7g/
- Подробнее: /questions/21211005/poluchit-vse-unikalnyie-znacheniya-v-massive-javascript-udalit-dublikatyi/21211016#21211016
Если вы не можете прочитать приведенный выше код, спросите, прочитайте книгу по javascript или вот несколько объяснений более короткого кода. /questions/32407889/kak-minimizirovat-kod-javascript/32407909#32407909
Это было просто другое решение, но отличное от остальных.
function diffArray(arr1, arr2) {
var newArr = arr1.concat(arr2);
newArr.sort();
var finalArr = [];
for(var i = 0;i<newArr.length;i++) {
if(!(newArr[i] === newArr[i+1] || newArr[i] === newArr[i-1])) {
finalArr.push(newArr[i]);
}
}
return finalArr;
}
Другой способ сделать это без написания большого количества кода - использовать ES5 Object.keys
-метод:
var arrayWithDuplicates = ['a','b','c','d','a','c'],
deduper = {};
arrayWithDuplicates.forEach(function (item) {
deduper[item] = null;
});
var dedupedArray = Object.keys(deduper); // ["a", "b", "c", "d"]
Извлечено в функции
function removeDuplicates (arr) {
var deduper = {}
arr.forEach(function (item) {
deduper[item] = null;
});
return Object.keys(deduper);
}
Самый простой способ удалить дубликаты - это выполнить цикл for, сравнить элементы, которые не совпадают, и вставить их в новый массив.
var array = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];
var removeDublicate = function(arr){
var result = []
var sort_arr = arr.sort() //=> optional
for (var i = 0; i < arr.length; i++) {
if(arr[ i + 1] !== arr[i] ){
result.push(arr[i])
}
};
return result
}
console.log(removeDublicate(array))
==> ["Adam", "Carl", "Jenny", "Matt", "Mike", "Nancy"]
function arrayDuplicateRemove(arr){
var c = 0;
var tempArray = [];
console.log(arr);
arr.sort();
console.log(arr);
for (var i = arr.length - 1; i >= 0; i--) {
if(arr[i] != tempArray[c-1]){
tempArray.push(arr[i])
c++;
}
};
console.log(tempArray);
tempArray.sort();
console.log(tempArray);
}
Самый простой способ удалить дубликаты строк - это использовать ассоциативный массив, а затем выполнить итерацию по ассоциативному массиву, чтобы вернуть список / массив обратно.
Как ниже:
var toHash = [];
var toList = [];
// add from ur data list to hash
$(data.pointsToList).each(function(index, Element) {
toHash[Element.nameTo]= Element.nameTo;
});
// now convert hash to array
// don't forget the "hasownproperty" else u will get random results
for (var key in toHash) {
if (toHash.hasOwnProperty(key)) {
toList.push(toHash[key]);
}
}
Вуаля, теперь дубликаты исчезли!
Метод вложенного цикла для удаления дубликатов в массиве и сохранения исходного порядка элементов.
var array = [1, 3, 2, 1, [5], 2, [4]]; // INPUT
var element = 0;
var decrement = array.length - 1;
while(element < array.length) {
while(element < decrement) {
if (array[element] === array[decrement]) {
array.splice(decrement, 1);
decrement--;
} else {
decrement--;
}
}
decrement = array.length - 1;
element++;
}
console.log(array);// [1, 3, 2, [5], [4]]
Объяснение: Внутренний цикл сравнивает первый элемент массива со всеми другими элементами, начиная с элемента с наибольшим индексом. Уменьшение по направлению к первому элементу дубликат дублируется из массива.
Когда внутренний цикл завершен, внешний цикл увеличивается до следующего элемента для сравнения и сбрасывает новую длину массива.
Вот еще один подход с использованием JQuery,
function uniqueArray(array){
if ($.isArray(array)){
var dupes = {}; var len, i;
for (i=0,len=array.length;i<len;i++){
var test = array[i].toString();
if (dupes[test]) { array.splice(i,1); len--; i--; } else { dupes[test] = true; }
}
}
else {
if (window.console) console.log('Not passing an array to uniqueArray, returning whatever you sent it - not filtered!');
return(array);
}
return(array);
}
Автор: Уильям Скидмор
Я знаю, что немного опоздал, но вот еще один вариант, используя jinqJs
var result = jinqJs().from(["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"]).distinct().select();
const numbers = [1, 1, 2, 3, 4, 4];
function unique(array) {
return array.reduce((a,b) => {
let isIn = a.find(element => {
return element === b;
});
if(!isIn){
a.push(b);
}
return a;
},[]);
}
let ret = unique(numbers); // [1, 2, 3, 4]
способ использования уменьшить и найти.
function removeDuplicates(inputArray) {
var outputArray=new Array();
if(inputArray.length>0){
jQuery.each(inputArray, function(index, value) {
if(jQuery.inArray(value, outputArray) == -1){
outputArray.push(value);
}
});
}
return outputArray;
}
Это решение использует новый массив и карту объектов внутри функции. Все, что он делает, это перебирает исходный массив и добавляет каждое целое число в карту объекта. Если, перебирая исходный массив, он сталкивается с повторением,
`if (!unique[int])`
ловит это, потому что уже есть ключевое свойство для объекта с таким же номером. Таким образом, пропуская это число и не позволяя его вставить в новый массив.
function removeRepeats(ints) {
var unique = {}
var newInts = []
for (var i = 0; i < ints.length; i++) {
var int = ints[i]
if (!unique[int]) {
unique[int] = 1
newInts.push(int)
}
}
return newInts
}
var example = [100, 100, 100, 100, 500]
console.log(removeRepeats(example)) // prints [100, 500]
Если вы создаете массив самостоятельно, вы можете сохранить цикл и дополнительный уникальный фильтр, выполняя проверку при вставке данных;
var values = [];
$.each(collection, function() {
var x = $(this).value;
if (!$.inArray(x, values)) {
values.push(x);
}
});
var duplicates = function(arr){
var sorted = arr.sort();
var dup = [];
for(var i=0; i<sorted.length; i++){
var rest = sorted.slice(i+1); //slice the rest of array
if(rest.indexOf(sorted[i]) > -1){//do indexOf
if(dup.indexOf(sorted[i]) == -1)
dup.push(sorted[i]);//store it in another arr
}
}
console.log(dup);
}
duplicates(["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"]);
Быстро и легко с помощью lodash - var array = ["12346","12347","12348","12349","12349"]; console.log(_.uniqWith(array,_.isEqual));
var lines = ["Mike", "Matt", "Nancy", "Adam", "Jenny", "Nancy", "Carl"];
var uniqueNames = [];
for(var i=0;i<lines.length;i++)
{
if(uniqueNames.indexOf(lines[i]) == -1)
uniqueNames.push(lines[i]);
}
if(uniqueNames.indexOf(uniqueNames[uniqueNames.length-1])!= -1)
uniqueNames.pop();
for(var i=0;i<uniqueNames.length;i++)
{
document.write(uniqueNames[i]);
document.write("<br/>");
}
aLinks - это простой объект массива JavaScript. Если какой-либо элемент существует перед элементами, по которым индекс показывает, что дубликат записи удален. Я повторяю, чтобы отменить все дубликаты. Один проход массива отменяет больше записей.
var srt_ = 0;
var pos_ = 0;
do {
var srt_ = 0;
for (var i in aLinks) {
pos_ = aLinks.indexOf(aLinks[i].valueOf(), 0);
if (pos_ < i) {
delete aLinks[i];
srt_++;
}
}
} while (srt_ != 0);
function removeDuplicates (array) {
var sorted = array.slice().sort()
var result = []
sorted.forEach((item, index) => {
if (sorted[index + 1] !== item) {
result.push(item)
}
})
return result
}
Решения Vanilla JS со сложностью O(n) (максимально быстрый для этой задачи). Измените hashFunction, чтобы различать объекты (например, 1 и "1"), если это необходимо. Первое решение позволяет избежать скрытых циклов (обычно в функциях, предоставляемых Array).
var dedupe = function(a)
{
var hash={},ret=[];
var hashFunction = function(v) { return ""+v; };
var collect = function(h)
{
if(hash.hasOwnProperty(hashFunction(h)) == false) // O(1)
{
hash[hashFunction(h)]=1;
ret.push(h); // should be O(1) for Arrays
return;
}
};
for(var i=0; i<a.length; i++) // this is a loop: O(n)
collect(a[i]);
//OR: a.forEach(collect); // this is a loop: O(n)
return ret;
}
var dedupe = function(a)
{
var hash={};
var isdupe = function(h)
{
if(hash.hasOwnProperty(h) == false) // O(1)
{
hash[h]=1;
return true;
}
return false;
};
return a.filter(isdupe); // this is a loop: O(n)
}
var uniqueCompnies = function(companyArray) {
var arrayUniqueCompnies = [],
found, x, y;
for (x = 0; x < companyArray.length; x++) {
found = undefined;
for (y = 0; y < arrayUniqueCompnies.length; y++) {
if (companyArray[x] === arrayUniqueCompnies[y]) {
found = true;
break;
}
}
if ( ! found) {
arrayUniqueCompnies.push(companyArray[x]);
}
}
return arrayUniqueCompnies;
}
var arr = [
"Adobe Systems Incorporated",
"IBX",
"IBX",
"BlackRock, Inc.",
"BlackRock, Inc.",
];
Если вы не хотите включать целую библиотеку, вы можете использовать эту, чтобы добавить метод, который может использовать любой массив:
Array.prototype.uniq = function uniq() {
return this.reduce(function(accum, cur) {
if (accum.indexOf(cur) === -1) accum.push(cur);
return accum;
}, [] );
}
["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"].uniq()
ES2015, 1-вкладыш, который хорошо сцепляется с map
, но работает только для целых чисел:
[1, 4, 1].sort().filter((current, next) => current !== next)
[1, 4]