Получить все неуникальные значения (т.е. дубликаты / более одного вхождения) в массиве

Question

Мне нужно проверить массив JavaScript, чтобы увидеть, есть ли какие-либо повторяющиеся значения. Какой самый простой способ сделать это? Мне просто нужно выяснить, что такое дублированные значения - мне не нужны их индексы или сколько раз они дублируются.

Я знаю, что могу перебрать массив и проверить все остальные значения на совпадение, но, похоже, должен быть более простой способ. Есть идеи? Спасибо!

Подобный вопрос:

• Получить все уникальные значения в массиве (удалить дубликаты)

Answer 1

Это также можно решить с помощью Set().

Значение в наборе может встречаться только один раз; оно уникально в коллекции набора.

    Array.prototype.hasDuplicates = function () {
        if (arr.length !== (new Set(arr).size)) {
            return true;
        }
        return false;
    }

Больше информации о наборах: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set

Примечание: Наборы не полностью поддерживаются в IE.

Answer 2

1. Печать повторяющихся значений

 var arr = [1,2,3,4,13,2,3,4,3,4];

    // non_unique Printing 
    function nonUnique(arr){
    var result = [];
    for(var i =0;i<arr.length;i++){
        if(arr.indexOf(arr[i],i+1) > -1){
            result.push(arr[i]);
        }
    }
    console.log(result);
    }nonUnique(arr);

    // unique Printing
    function uniqueDuplicateVal(arr){
       var result = [];
       for(var i =0;i<arr.length;i++){
        if(arr.indexOf(arr[i],i+1) > -1){
          if(result.indexOf(arr[i]) === -1]){
             result.push(arr[i]);
          }
        }
       }    
    }
    uniqueDuplicateVal(arr)

Answer 3

Это должен быть один из самых коротких и простых способов на самом деле найти повторяющиеся значения в массиве.

var arr = [1,2,3,4,5,6,7,8,1,2,3,4,5,3,3,4];
var data = arr.filter(function(item,index,arr){
  return arr.indexOf(item) != arr.lastIndexOf(item) && arr.indexOf(item) == index;
})

console.log(data );

Answer 4

Это наиболее эффективный способ, который я могу представить, поскольку он не включает Array.indexOf() или Array.lastIndexOf(), которые имеют сложность O (n), и использование внутри любого цикла сложности O (n) сделает полную сложность O (n) ^ 2).

Мой первый цикл имеет сложность O (n / 2) или O ((n / 2) + 1), так как сложность поиска в хэше равна O (1). Наихудшая сложность второго цикла, когда в массиве нет дубликатов, равна O (n), а наилучшая сложность, когда дубликат каждого элемента - O (n / 2).

function duplicates(arr) {
  let duplicates = [],
      d = {},
      i = 0,
      j = arr.length - 1;

  // Complexity O(n/2)
  while (i <= j) {
    if (i === j)
      d[arr[i]] ? d[arr[i]] += 1 : d[arr[i]] = 1;  // Complexity O(1)
    else {
      d[arr[i]] ? d[arr[i]] += 1 : d[arr[i]] = 1;  // Complexity O(1)
      d[arr[j]] ? d[arr[j]] += 1 : d[arr[j]] = 1;  // Complexity O(1)
    }

    ++i;
    --j;
  }

  // Worst complexity O(n), best complexity O(n/2)
  for (let k in d) {
    if (d[k] > 1)
      duplicates.push(k);
  }

  return duplicates;

}

console.log(duplicates([5,6,4,9,2,3,5,3,4,1,5,4,9]));
console.log(duplicates([2,3,4,5,4,3,4]));
console.log(duplicates([4,5,2,9]));
console.log(duplicates([4,5,2,9,2,5,9,4]));

Answer 5

//find duplicates:
//sort, then reduce - concat values equal previous element, skip others

//input
var a = [1, 2, 3, 1, 2, 1, 2]

//short version:
var duplicates = a.sort().reduce((d, v, i, a) => i && v === a[i - 1] ? d.concat(v) : d, [])
console.log(duplicates); //[1, 1, 2, 2]

//readable version:
var duplicates = a.sort().reduce((output, element, index, input) => {
  if ((index > 0) && (element === input[index - 1]))
    return output.concat(element)
  return output
}, [])
console.log(duplicates); //[1, 1, 2, 2]

Answer 6

Самый быстрый способ решить это на самом деле с флагом

var values = [4,2,3,1,4]

// solution
const checkDuplicate = list => {
  var hasDuplicate = false;
  list.sort().sort((a, b) => {
    if (a === b) hasDuplicate = true
  })
  return hasDuplicate
}

console.log(checkDuplicate(values))

Answer 7

Из ответа Рафаэля Монтанаро, его можно улучшить, используя элемент массива / объекта следующим образом.

function eliminateDuplicates(arr) {
  var len = arr.length,
      out = [],
      obj = {};

  for (var key, i=0; i < len; i++) {
    key = JSON.stringify(arr[i]);
    obj[key] = (obj[key]) ? obj[key] + 1 : 1;
  }
  for (var key in obj) {
    out.push(JSON.parse(key));
  }
  return [out, obj];
}

Примечание. Необходимо использовать библиотеку JSON для браузера, который не поддерживает JSON.

Answer 8

Я пытаюсь улучшить ответ от @swilliams, это вернет массив без дубликатов.

// arrays for testing
var arr = [9, 9, 111, 2, 3, 4, 4, 5, 7];

// ascending order
var sorted_arr = arr.sort(function(a,b){return a-b;}); 

var arr_length = arr.length;
var results = [];
if(arr_length){
    if(arr_length == 1){
        results = arr;
    }else{
        for (var i = 0; i < arr.length - 1; i++) {
            if (sorted_arr[i + 1] != sorted_arr[i]) {
                results.push(sorted_arr[i]);
            }
            // for last element
            if (i == arr.length - 2){
                results.push(sorted_arr[i+1]);
            }
        }
    }
}

alert(results);

Answer 9

Это более продвинутая функция, основанная на количестве вхождений.

function getMostDuplicated(arr, count) {
      const result = [];
      arr.forEach((item) => {
        let i = 0;
        arr.forEach((checkTo) => {
          if (item === checkTo) {
            i++;
            if (i === count && result.indexOf(item) === -1) {
              result.push(item);
            }
          }
        });
      });
      return result;
}

arr = [1,1,1,2,5,67,3,2,3,2,3,1,2,3,4,1,4];
result = getMostDuplicated(arr, 5); // result is 1
result = getMostDuplicated(arr, 2); // result 1, 2, 3, 4
console.log(result);

Answer 10

Вот один из них, реализованный с использованием sort () и JSON.stringify ()

https://gist.github.com/korczis/7598657

function removeDuplicates(vals) {
    var res = [];
    var tmp = vals.sort();

    for (var i = 0; i < tmp.length; i++) {
        res.push(tmp[i]);
                    while (JSON.stringify(tmp[i]) == JSON.stringify(tmp[i + 1])) {
            i++;
        }
    }

    return res;
}
console.log(removeDuplicates([1,2,3,4,5,4,3,3,2,1,]));