У мене є масив чисел, який мені потрібно переконатися, що вони унікальні. Нижче я знайшов фрагмент коду в Інтернеті, і він чудово працює, поки масив не має нуля. Я знайшов цей інший скрипт тут на Stack Overflow, який виглядає майже так, як він, але він не виходить з ладу.

Тож заради того, щоб допомогти мені навчитися, чи може хтось допомогти мені визначити, де сценарій прототипу йде не так?

Array.prototype.getUnique = function() {
 var o = {}, a = [], i, e;
 for (i = 0; e = this[i]; i++) {o[e] = 1};
 for (e in o) {a.push (e)};
 return a;
}

Більше відповідей з повторного запитання:

• Видаліть повторювані значення з масиву JS

Подібне запитання:

• Отримати в масиві всі не унікальні значення (тобто: дублікат / декілька випадків)

За допомогою JavaScript 1.6 / ECMAScript 5 ви можете використовувати власний filterметод масиву таким чином, щоб отримати масив з унікальними значеннями:

function onlyUnique(value, index, self) { 
    return self.indexOf(value) === index;
}

// usage example:
var a = ['a', 1, 'a', 2, '1'];
var unique = a.filter( onlyUnique ); // returns ['a', 1, 2, '1']

Нативний метод filterпройде через масив і залишить лише ті записи, які передають дану функцію зворотного виклику onlyUnique.

onlyUniqueперевіряє, чи задане значення є першим. Якщо ні, він повинен бути дублікатом і не буде скопійований.

Це рішення працює без додаткової бібліотеки, наприклад jQuery або prototype.js.

Він також працює для масивів зі змішаними типами значень.

Для старих браузерів (<ie9), які не підтримують нативні методи, filterі indexOfви можете знайти робочі кола в документації MDN для фільтра та indexOf .

Якщо ви хочете зберегти останнє виникнення значення, просто замініть indexOfйого lastIndexOf.

З ES6 це можна скоротити до цього:

// usage example:
var myArray = ['a', 1, 'a', 2, '1'];
var unique = myArray.filter((v, i, a) => a.indexOf(v) === i); 

// unique is ['a', 1, 2, '1']

Дякуємо Каміло Мартіну за натяк у коментарі.

ES6 має власний об'єкт Setдля зберігання унікальних значень. Щоб отримати масив з унікальними значеннями, ви можете зробити це зараз:

var myArray = ['a', 1, 'a', 2, '1'];

let unique = [...new Set(myArray)]; 

// unique is ['a', 1, 2, '1']

Конструктор з Setприймає ітерабельний об'єкт, як-от Array, а оператор розповсюдження ...перетворює набір назад у масив. Дякуємо Лукасу Лізе за натяк у коментарі.

Оновлена ​​відповідь для ES6 / ES2015 : Використовуючи набір , рішення для єдиного рядка:

var items = [4,5,4,6,3,4,5,2,23,1,4,4,4]
var uniqueItems = Array.from(new Set(items))

Який повертається

[4, 5, 6, 3, 2, 23, 1]

Як пропонує le_m , це також можна скоротити, використовуючи оператор розширення , наприклад

var uniqueItems = [...new Set(items)]

Я усвідомлюю, що на це питання вже є понад 30 відповідей. Але я перечитав спочатку всі існуючі відповіді та зробив власне дослідження.

Я розділив усі відповіді на 4 можливі рішення:

1. Використовуйте нову функцію ES6: [...new Set( [1, 1, 2] )];
2. Використовуйте об'єкт { }для запобігання дублікатів
3. Використовуйте допоміжний масив [ ]
4. Використовуйте filter + indexOf

Ось зразкові коди, знайдені у відповідях:

Використовуйте нову функцію ES6: [...new Set( [1, 1, 2] )];

function uniqueArray0(array) {
  var result = Array.from(new Set(array));
  return result    
}

Використовуйте об'єкт { }для запобігання дублікатів

function uniqueArray1( ar ) {
  var j = {};

  ar.forEach( function(v) {
    j[v+ '::' + typeof v] = v;
  });

  return Object.keys(j).map(function(v){
    return j[v];
  });
} 

Використовуйте допоміжний масив [ ]

function uniqueArray2(arr) {
    var a = [];
    for (var i=0, l=arr.length; i<l; i++)
        if (a.indexOf(arr[i]) === -1 && arr[i] !== '')
            a.push(arr[i]);
    return a;
}

Використовуйте filter + indexOf

function uniqueArray3(a) {
  function onlyUnique(value, index, self) { 
      return self.indexOf(value) === index;
  }

  // usage
  var unique = a.filter( onlyUnique ); // returns ['a', 1, 2, '1']

  return unique;
}

І я задумався, хто з них швидший. Я зробив зразок Google Sheet для тестування функцій. Примітка. ECMA 6 недоступний у Google Таблицях, тому я не можу перевірити його.

Ось результат тестів:

Я очікував, що код, що використовує об'єкт { }, виграє, оскільки він використовує хеш. Тож я радий, що тести показали найкращі результати для цього алгоритму в Chrome та IE. Дякуємо @rab за код .

Ви також можете використовувати underscore.js .

console.log(_.uniq([1, 2, 1, 3, 1, 4]));

<script src="http://underscorejs.org/underscore-min.js"></script>

який повернеться:

[1, 2, 3, 4]

Один вкладиш, чистий JavaScript

З синтаксисом ES6

list = list.filter((x, i, a) => a.indexOf(x) == i)

x --> item in array
i --> index of item
a --> array reference, (in this case "list")

З синтаксисом ES5

list = list.filter(function (x, i, a) { 
    return a.indexOf(x) == i; 
});

Сумісність браузера : IE9 +

З тих пір я знайшов хороший метод, який використовує jQuery

arr = $.grep(arr, function(v, k){
    return $.inArray(v ,arr) === k;
});

Примітка: Цей код був знятий з пункту пробивання качки Пола Ірландського - я забув дати кредит: P

Найкоротше рішення з ES6: [...new Set( [1, 1, 2] )];

Або якщо ви хочете змінити прототип масиву (як в оригінальному запитанні):

Array.prototype.getUnique = function() {
    return [...new Set( [this] )];
};

Наразі EcmaScript 6 лише частково реалізований у сучасних браузерах (серпень 2015 р.), Але Babel стала дуже популярною для перенесення ES6 (і навіть ES7) назад в ES5. Таким чином ви сьогодні можете написати код ES6!

Якщо вам цікаво, що ...означає, це називається оператором розповсюдження . Від MDN : «Оператор розповсюдження дозволяє розширити вираз у місцях, де очікується багато аргументів (для викликів функцій) або декількох елементів (для літералів масиву)». Оскільки набір є ітерабельним (і може мати лише унікальні значення), оператор розповсюдження розширить набір для заповнення масиву.

Ресурси для вивчення ES6:

• Дослідження ES6 доктора Акселя Раушмаєра
• Шукайте "ES6" з щотижневих бюлетенів JS
• ES6 в поглиблених статтях з блогу Mozilla Hacks

Найпростіше рішення:

var arr = [1, 3, 4, 1, 2, 1, 3, 3, 4, 1];
console.log([...new Set(arr)]);

Або:

var arr = [1, 3, 4, 1, 2, 1, 3, 3, 4, 1];
console.log(Array.from(new Set(arr)));

Найпростіший і найшвидший (у Chrome) спосіб зробити це:

Array.prototype.unique = function() {
    var a = [];
    for (var i=0, l=this.length; i<l; i++)
        if (a.indexOf(this[i]) === -1)
            a.push(this[i]);
    return a;
}

Просто проходить кожен елемент у масиві, перевіряє, чи цей елемент уже є у списку, а якщо його немає, натисніть на масив, який повертається.

За словами jsPerf, ця функція є найшвидшою з тих, кого я могла знайти де завгодно - хоч і не соромтесь додати свою власну.

Не прототип версії:

function uniques(arr) {
    var a = [];
    for (var i=0, l=arr.length; i<l; i++)
        if (a.indexOf(arr[i]) === -1 && arr[i] !== '')
            a.push(arr[i]);
    return a;
}

Сортування

Якщо також потрібно сортувати масив, найшвидшим є наступне:

Array.prototype.sortUnique = function() {
    this.sort();
    var last_i;
    for (var i=0;i<this.length;i++)
        if ((last_i = this.lastIndexOf(this[i])) !== i)
            this.splice(i+1, last_i-i);
    return this;
}

або непрототип:

function sortUnique(arr) {
    arr.sort();
    var last_i;
    for (var i=0;i<arr.length;i++)
        if ((last_i = arr.lastIndexOf(arr[i])) !== i)
            arr.splice(i+1, last_i-i);
    return arr;
}

Це також швидше, ніж описаний вище метод у більшості нехромованих браузерів.

ТІЛЬКІСТЬ! цей код, ймовірно, у 10 разів швидший, ніж усі коди тут * працює у всіх браузерах, а також має найменший вплив пам’яті .... і багато іншого

якщо вам не потрібно повторно використовувати старий масив; btw зробіть необхідні інші операції, перш ніж перетворити його на унікальний тут, мабуть, найшвидший спосіб зробити це, також дуже короткий.

var array=[1,2,3,4,5,6,7,8,9,0,1,2,1];

то ви можете спробувати це

var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 1];

function toUnique(a, b, c) { //array,placeholder,placeholder
  b = a.length;
  while (c = --b)
    while (c--) a[b] !== a[c] || a.splice(c, 1);
  return a // not needed ;)
}
console.log(toUnique(array));
//[3, 4, 5, 6, 7, 8, 9, 0, 2, 1]

Я придумав цю функцію, читаючи цю статтю ...

http://www.shamasis.net/2009/09/fast-algorithm-to-find-unique-items-in-javascript-array/

Мені не подобається цикл for. він має багато параметрів. Я люблю цикл while--. в той час як це найшвидший цикл у всіх браузерах, крім того, який ми всі так любимо ... хром.

у будь-якому випадку я написав першу функцію, яка використовує while.Aep так це трохи швидше, ніж функція, знайдена в Article.але недостатньо.unique2()

Наступний крок - використання сучасних js. Object.keys я замінив інший для циклу на Object.keys js1.7 ... трохи швидше і коротше (у хромі на 2 рази швидше);). Недостатньо!. unique3().

в цей момент я думав про те, що мені справді потрібно в моїй унікальній функції. мені не потрібен старий масив, я хочу швидку функцію. тому я використав 2, а петлі + зрощення.unique4()

Марно сказати, що я був вражений.

хром: звичайні 150 000 операцій в секунду підскочили до 1800 000 операцій в секунду.

тобто: 80 000 оп / с проти 3 500 000 оп / с

ios: 18 000 op / s проти 170 000 op / s

сафарі: 80 000 оп / с проти 6 000 000 оп / с

Доказ http://jsperf.com/wgu або краще використовувати console.time ... microtime ... все, що завгодно

unique5() це просто показати вам, що відбувається, якщо ви хочете зберегти старий масив.

Не використовуйте, Array.prototypeякщо ви не знаєте, чим займаєтесь. Я щойно зробив багато копій та минулий. Використовуйте, Object.defineProperty(Array.prototype,...,writable:false,enumerable:false})якщо ви хочете створити власний prototype.example: https://stackoverflow.com/a/20463021/2450730

Демонстрація http://jsfiddle.net/46S7g/

ПРИМІТКА: ваш старий масив після цієї операції знищується / стаєуніке.

якщо ви не можете прочитати код вище, запитайте, прочитайте книгу javascript або ось кілька пояснень щодо коротшого коду. https://stackoverflow.com/a/21353032/2450730

деякі використовують indexOf ... не ... http://jsperf.com/dgfgghfghfghghgfhgfhfghfhgfh

для порожніх масивів

!array.length||toUnique(array); 

Багато відповідей тут, можливо, не корисні новачкам. Якщо видалити копію масиву важко, вони дійсно будуть знати про прототип ланцюга чи навіть jQuery?

У сучасних веб-переглядачах чистим і простим рішенням є зберігання даних у наборі , який призначений для переліку унікальних значень.

const cars = ['Volvo', 'Jeep', 'Volvo', 'Lincoln', 'Lincoln', 'Ford'];
const uniqueCars = Array.from(new Set(cars));

Array.fromКорисно перетворити Set назад в масив , так що у вас є вільний доступ до всіх з дивних методів (функцій) , що масиви мають. Є й інші способи зробити те саме. Але вам це взагалі не знадобиться Array.from, оскільки набори мають безліч корисних функцій, таких як forEach .

Якщо вам потрібно підтримувати старий Internet Explorer, і тому ви не можете використовувати Set, то простою технікою є копіювання елементів у новий масив, попередньо перевіряючи, чи вони вже є в новому масиві.

// Create a list of cars, with duplicates.
var cars = ['Volvo', 'Jeep', 'Volvo', 'Lincoln', 'Lincoln', 'Ford'];
// Create a list of unique cars, to put a car in if we haven't already.
var uniqueCars = [];

// Go through each car, one at a time.
cars.forEach(function (car) {
    // The code within the following block runs only if the
    // current car does NOT exist in the uniqueCars list
    // - a.k.a. prevent duplicates
    if (uniqueCars.indexOf(car) === -1) {
        // Since we now know we haven't seen this car before,
        // copy it to the end of the uniqueCars list.
        uniqueCars.push(car);
    }
});

Щоб зробити це миттєво багаторазовим використання, давайте поставимо його у функцію.

function deduplicate(data) {
    if (data.length > 0) {
        var result = [];

        data.forEach(function (elem) {
            if (result.indexOf(elem) === -1) {
                result.push(elem);
            }
        });

        return result;
    }
}

Отже, щоб позбутися дублікатів, ми б зараз це зробили.

var uniqueCars = deduplicate(cars);

deduplicate(cars)Частина стає річчю ми назвали результат , коли функція завершується.

Просто передайте ім'я будь-якого вподобаного масиву.

["Defects", "Total", "Days", "City", "Defects"].reduce(function(prev, cur) {
  return (prev.indexOf(cur) < 0) ? prev.concat([cur]) : prev;
 }, []);

[0,1,2,0,3,2,1,5].reduce(function(prev, cur) {
  return (prev.indexOf(cur) < 0) ? prev.concat([cur]) : prev;
 }, []);

Це можна зробити за допомогою наборів ES6:

var duplicatedArray = [1, 2, 3, 4, 5, 1, 1, 1, 2, 3, 4];
var uniqueArray = Array.from(new Set(duplicatedArray));

console.log(uniqueArray);

// Вихід буде

uniqueArray = [1,2,3,4,5];

Цей прототип getUniqueне зовсім коректний, тому що якщо у мене є масив типу: ["1",1,2,3,4,1,"foo"]він повернеться ["1","2","3","4"]і "1"є рядковим і 1є цілим числом; вони різні.

Ось правильне рішення:

Array.prototype.unique = function(a){
    return function(){ return this.filter(a) }
}(function(a,b,c){ return c.indexOf(a,b+1) < 0 });

використовуючи:

var foo;
foo = ["1",1,2,3,4,1,"foo"];
foo.unique();

Наведене вище призведе ["1",2,3,4,1,"foo"].

Не розширюючи Array.prototype (це кажуть, що це погана практика) або використовуючи jquery / підкреслення, ви можете просто filterмасив.

Зберігаючи останнє явище:

    function arrayLastUnique(array) {
        return array.filter(function (a, b, c) {
            // keeps last occurrence
            return c.indexOf(a, b + 1) < 0;
        });
    },

або перше виникнення:

    function arrayFirstUnique(array) {
        return array.filter(function (a, b, c) {
            // keeps first occurrence
            return c.indexOf(a) === b;
        });
    },

Ну, це лише javascript ECMAScript 5+, що означає лише IE9 +, але це приємно для розвитку в рідному HTML / JS (додаток для Windows Store, Firefox OS, Sencha, Phonegap, Titanium, ...).

Магія

a.filter(e=>!(t[e]=e in t)) 

O (n) продуктивність ; ми припускаємо, що ваш масив знаходиться в aі t={}. Пояснення тут (+ імп . Jeppe )

let t={}, unique= a=> a.filter(e=>!(t[e]=e in t));

// "stand-alone" version working with global t:
// a1.filter((t={},e=>!(t[e]=e in t)));

// Test data
let a1 = [5,6,0,4,9,2,3,5,0,3,4,1,5,4,9];
let a2 = [[2, 17], [2, 17], [2, 17], [1, 12], [5, 9], [1, 12], [6, 2], [1, 12]];
let a3 = ['Mike', 'Adam','Matt', 'Nancy', 'Adam', 'Jenny', 'Nancy', 'Carl'];

// Results
console.log(JSON.stringify( unique(a1) ))
console.log(JSON.stringify( unique(a2) ))
console.log(JSON.stringify( unique(a3) ))

[...new Set(duplicates)]

Це найпростіший і на який посилаються MDN Web Docs .

const numbers = [2,3,4,4,2,3,3,4,4,5,5,6,6,7,5,32,3,4,5]
console.log([...new Set(numbers)]) // [2, 3, 4, 5, 6, 7, 32]

Якщо ви використовуєте прототипний фреймворк, немає необхідності робити цикли 'for', ви можете використовувати http://www.prototypejs.org/api/array/uniq так:

var a = Array.uniq();  

Який створить дублікат масиву без дублікатів. Я натрапив на ваше запитання, шукаючи спосіб підрахувати різні записи масиву, щоб потім

uniq ()

я використав

розмір ()

і був мій простий результат. ps Вибачте, якщо я щось неправильно ввів

редагувати: якщо ви хочете уникати невизначених записів, ви можете додати

компактний ()

раніше, як це:

var a = Array.compact().uniq();  

Тепер за допомогою наборів ви можете видалити дублікати та перетворити їх назад у масив.

var names = ["Mike","Matt","Nancy", "Matt","Adam","Jenny","Nancy","Carl"];

console.log([...new Set(names)])

Іншим рішенням є використання сортування та фільтрування

var names = ["Mike","Matt","Nancy", "Matt","Adam","Jenny","Nancy","Carl"];
var namesSorted = names.sort();
const result = namesSorted.filter((e, i) => namesSorted[i] != namesSorted[i+1]);
console.log(result);

Це тому 0, що це хибне значення в JavaScript.

this[i] буде помилковим, якщо значення масиву дорівнює 0 або будь-яке інше значення фальсифікації.

Array.prototype.getUnique = function() {
    var o = {}, a = []
    for (var i = 0; i < this.length; i++) o[this[i]] = 1
    for (var e in o) a.push(e)
    return a
}

У мене була дещо інша проблема, коли мені потрібно було видалити об’єкти з подвійними властивостями id з масиву. це спрацювало.

let objArr = [{
  id: '123'
}, {
  id: '123'
}, {
  id: '456'
}];

objArr = objArr.reduce((acc, cur) => [
  ...acc.filter((obj) => obj.id !== cur.id), cur
], []);

console.log(objArr);

Найпростіша відповідь:

const array = [1, 1, 2, 2, 3, 5, 5, 2];
const uniqueArray = [...new Set(array)];
console.log(uniqueArray); // [1, 2, 3, 5]

Я не впевнений, чому Габріель Сільвейра написав цю функцію саме так, але простіша форма, яка працює для мене так само добре і без мінімізації:

Array.prototype.unique = function() {
  return this.filter(function(value, index, array) {
    return array.indexOf(value, index + 1) < 0;
  });
};

або в CoffeeScript:

Array.prototype.unique = ->
  this.filter( (value, index, array) ->
    array.indexOf(value, index + 1) < 0
  )

Якщо у вас все в порядку із додатковими залежностями або у вас вже є одна з бібліотек у вашій кодовій базі, ви можете видалити дублікати з масиву на місці, використовуючи LoDash (або підкреслення).

Використання

Якщо у вас ще немає кодової бази, встановіть її за допомогою npm:

npm install lodash

Потім використовуйте його наступним чином:

import _ from 'lodash';
let idArray = _.uniq ([
    1,
    2,
    3,
    3,
    3
]);
console.dir(idArray);

Вийшов:

[ 1, 2, 3 ]

На це відповіли багато, але це не відповіло на мою особливу потребу.

Багато відповідей виглядають так:

a.filter((item, pos, self) => self.indexOf(item) === pos);

Але це не працює для масивів складних об'єктів.

Скажіть, у нас такий масив:

const a = [
 { age: 4, name: 'fluffy' },
 { age: 5, name: 'spot' },
 { age: 2, name: 'fluffy' },
 { age: 3, name: 'toby' },
];

Якщо ми хочемо, щоб об'єкти мали унікальні імена, ми повинні використовувати array.prototype.findIndexзамість array.prototype.indexOf:

a.filter((item, pos, self) => self.findIndex(v => v.name === item.name) === pos);

Від Shamasis Бхаттачарія блогу «s (O (2n) тимчасової складності):

Array.prototype.unique = function() {
    var o = {}, i, l = this.length, r = [];
    for(i=0; i<l;i+=1) o[this[i]] = this[i];
    for(i in o) r.push(o[i]);
    return r;
};

З блогу Пола Ірландського : поліпшення JQuery .unique():

(function($){

    var _old = $.unique;

    $.unique = function(arr){

        // do the default behavior only if we got an array of elements
        if (!!arr[0].nodeType){
            return _old.apply(this,arguments);
        } else {
            // reduce the array to contain no dupes via grep/inArray
            return $.grep(arr,function(v,k){
                return $.inArray(v,arr) === k;
            });
        }
    };
})(jQuery);

// in use..
var arr = ['first',7,true,2,7,true,'last','last'];
$.unique(arr); // ["first", 7, true, 2, "last"]

var arr = [1,2,3,4,5,4,3,2,1];
$.unique(arr); // [1, 2, 3, 4, 5]

Пошук унікальних значень масиву простим методом

function arrUnique(a){
  var t = [];
  for(var x = 0; x < a.length; x++){
    if(t.indexOf(a[x]) == -1)t.push(a[x]);
  }
  return t;
}
arrUnique([1,4,2,7,1,5,9,2,4,7,2]) // [1, 4, 2, 7, 5, 9]

Здається, ми втратили відповідь Рафаеля , яка стояла як прийнята відповідь протягом декількох років. Це було (принаймні у 2017 році), найкращим рішенням, якщо у вас немає масиву змішаного типу :

Array.prototype.getUnique = function(){
    var u = {}, a = [];
    for (var i = 0, l = this.length; i < l; ++i) {
        if (u.hasOwnProperty(this[i])) {
            continue;
        }
        a.push(this[i]);
        u[this[i]] = 1;
    }
return a;
}

Якщо ви робите є масив змішаного типу, ви можете серіалізовать хеш - ключ:

Array.prototype.getUnique = function() {
    var hash = {}, result = [], key; 
    for ( var i = 0, l = this.length; i < l; ++i ) {
        key = JSON.stringify(this[i]);
        if ( !hash.hasOwnProperty(key) ) {
            hash[key] = true;
            result.push(this[i]);
        }
    }
    return result;
}

Щоб вирішити проблему навпаки, може бути корисним відсутність дубліката під час завантаження масиву, як це зробить Set object, але він доступний не у всіх браузерах. Це економить пам'ять і є більш ефективним, якщо вам потрібно переглянути його вміст багато разів.

Array.prototype.add = function (elem) {
   if (this.indexOf(elem) == -1) {
      this.push(elem);
   }
}

Зразок:

set = [];
[1,3,4,1,2,1,3,3,4,1].forEach(function(x) { set.add(x); });

Дає тобі set = [1,3,4,2]