Mam szereg liczb, które muszę upewnić się, że są unikalne. Fragment kodu znalazłem poniżej w Internecie i działa świetnie, dopóki tablica nie będzie miała zera. Znalazłem ten inny skrypt tutaj na przepełnieniu stosu, który wygląda prawie dokładnie tak, ale nie zawodzi.

Czy więc, aby pomóc mi w nauce, ktoś może mi pomóc ustalić, gdzie źle działa prototypowy skrypt?

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

Więcej odpowiedzi z duplikatu pytania:

• Usuń zduplikowane wartości z tablicy JS

Podobne pytanie:

• Uzyskaj wszystkie nieunikalne wartości (tj .: duplikat / więcej niż jedno wystąpienie) w tablicy

W JavaScript 1.6 / ECMAScript 5 możesz użyć natywnej filtermetody Array w następujący sposób, aby uzyskać tablicę o unikalnych wartościach:

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']

Metoda natywna filterbędzie pętla w tablicy i pozostawi tylko te wpisy, które przejdą daną funkcję wywołania zwrotnego onlyUnique.

onlyUniquesprawdza, czy podana wartość występuje po raz pierwszy. Jeśli nie, musi być duplikatem i nie zostanie skopiowany.

To rozwiązanie działa bez dodatkowej biblioteki, takiej jak jQuery lub prototype.js.

Działa również w przypadku tablic o mieszanych typach wartości.

Dla starych przeglądarek (<IE9), które nie obsługują metod natywnych filteri indexOfmożna znaleźć arounds praca w dokumentacji MDN na filtrze i indexOf .

Jeśli chcesz zachować ostatnie wystąpienie wartości, po prostu zamień indexOfna lastIndexOf.

Z ES6 można to skrócić do tego:

// 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']

Podziękowania dla Camilo Martina za podpowiedź w komentarzu.

ES6 ma obiekt macierzysty Setdo przechowywania unikalnych wartości. Aby uzyskać tablicę z unikalnymi wartościami, możesz teraz zrobić to:

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

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

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

Konstruktor Setpobiera iterowalny obiekt, taki jak Array, a operator rozkładania ...przekształca zestaw z powrotem w Array. Podziękowania dla Lukasa Liese za podpowiedź w komentarzu.

Zaktualizowana odpowiedź dla ES6 / ES2015 : Przy użyciu zestawu rozwiązanie jednoliniowe to:

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

Który zwraca

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

Jak sugeruje le_m , można to również skrócić za pomocą operatora spread , np

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

Zdaję sobie sprawę, że to pytanie ma już ponad 30 odpowiedzi. Ale najpierw przeczytałem wszystkie istniejące odpowiedzi i przeprowadziłem własne badania.

Podzielę wszystkie odpowiedzi na 4 możliwe rozwiązania:

1. Użyj nowej funkcji ES6: [...new Set( [1, 1, 2] )];
2. Użyj obiektu, { }aby zapobiec duplikatom
3. Użyj tablicy pomocniczej [ ]
4. Posługiwać się filter + indexOf

Oto przykładowe kody znalezione w odpowiedziach:

Użyj nowej funkcji ES6: [...new Set( [1, 1, 2] )];

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

Użyj obiektu, { }aby zapobiec duplikatom

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

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

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

Użyj tablicy pomocniczej [ ]

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

Posługiwać się 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;
}

I zastanawiałem się, który z nich jest szybszy. Zrobiłem przykładowy Arkusz Google do testowania funkcji. Uwaga: ECMA 6 nie jest dostępny w Arkuszach Google, więc nie mogę go przetestować.

Oto wynik testów:

Spodziewałem się, że kod wykorzystujący obiekt { }wygra, ponieważ używa skrótu. Cieszę się więc, że testy wykazały najlepsze wyniki dla tego algorytmu w Chrome i IE. Dzięki @rab za kod .

Możesz także użyć underscore.js .

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

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

który zwróci:

[1, 2, 3, 4]

One Liner, czysty JavaScript

Ze składnią 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")

Ze składnią ES5

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

Kompatybilność przeglądarki : IE9 +

Od tego czasu znalazłem fajną metodę, która używa jQuery

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

Uwaga: ten kod został pobrany z kaczy Paula Irlandczyka - zapomniałem podać kredyt: P

Najkrótsze rozwiązanie z ES6: [...new Set( [1, 1, 2] )];

Lub jeśli chcesz zmodyfikować prototyp Array (jak w pierwotnym pytaniu):

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

EcmaScript 6 jest obecnie tylko częściowo zaimplementowany w nowoczesnych przeglądarkach (sierpień 2015), ale Babel stał się bardzo popularny przy transpilowaniu ES6 (a nawet ES7) z powrotem do ES5. W ten sposób możesz napisać kod ES6 już dziś!

Jeśli zastanawiasz się, co to ...znaczy, nazywa się to operatorem rozprzestrzeniania . Z MDN : «Operator rozkładania pozwala na rozwinięcie wyrażenia w miejscach, w których oczekuje się wielu argumentów (dla wywołań funkcji) lub wielu elementów (dla literałów tablicowych)». Ponieważ zestaw jest iterowalny (i może mieć tylko unikalne wartości), operator rozkładania rozszerzy zestaw, aby wypełnić tablicę.

Materiały do ​​nauki ES6:

• Odkrywanie ES6 przez dr Axela Rauschmayera
• Wyszukaj „ES6” w cotygodniowych biuletynach JS
• ES6 dogłębnie artykuły z bloga Mozilla Hacks

Najprostsze rozwiązanie:

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

Lub:

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

Najprostszy i najszybszy (w Chrome) sposób:

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

Po prostu przechodzi przez każdy element w tablicy, sprawdza, czy ten element jest już na liście, a jeśli nie, przesuń do tablicy, która zostanie zwrócona.

Według jsPerf ta funkcja jest najszybsza z tych, jakie mogłem znaleźć wszędzie - możesz jednak dodać własną.

Nieprototypowa wersja:

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

Sortowanie

Gdy trzeba również posortować tablicę, najszybsze są następujące czynności:

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

lub nieprototypowy:

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

Jest to również szybsze niż powyższa metoda w większości przeglądarek innych niż Chrome.

TYLKO WYDAJNOŚĆ! ten kod jest prawdopodobnie 10 razy szybszy niż wszystkie kody tutaj * działa na wszystkich przeglądarkach, a także ma najmniejszy wpływ na pamięć .... i więcej

jeśli nie musisz ponownie używać starej tablicy; btw wykonaj niezbędne operacje, zanim skonwertujesz ją na unikalną, jest to prawdopodobnie najszybszy sposób na zrobienie tego, również bardzo krótki.

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

to możesz spróbować

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]

Wymyśliłem tę funkcję, czytając ten artykuł ...

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

Nie lubię pętli for. ma wiele parametrów. lubię pętlę while--. podczas gdy jest najszybszą pętlą we wszystkich przeglądarkach oprócz tej, którą wszyscy bardzo lubimy ... chrome.

w każdym razie napisałem pierwszą funkcję, która używa while. Tak, jest to trochę szybsze niż funkcja znaleziona w artykule. ale za mało.unique2()

w następnym kroku użyj nowoczesnego js. Object.keys drugą pętlę for zastąpiłem Object.keys js1.7 ... trochę szybciej i krócej (w chrome 2x szybciej);). Niewystarczająco!. unique3().

w tym momencie myślałem o tym, czego naprawdę potrzebuję w MOJEJ unikalnej funkcji. nie potrzebuję starej tablicy, chcę szybkiej funkcji. więc użyłem 2 pętli while + splot.unique4()

Nie trzeba dodawać, że byłem pod wrażeniem.

chrome: zwykłe 150 000 operacji na sekundę skoczyło do 1 800 000 operacji na sekundę.

tj. 80 000 operacji na sekundę w porównaniu do 35 000 000 operacji na sekundę

ios: 18 000 operacji na sekundę vs 170 000 operacji na sekundę

safari: 80 000 operacji na sekundę vs 6 000 000 operacji na sekundę

Dowód http://jsperf.com/wgu lub lepiej użyj console.time ... microtime ... cokolwiek

unique5() jest po prostu pokazanie, co się stanie, jeśli chcesz zachować starą tablicę.

Nie używaj, Array.prototypejeśli nie wiesz, co robisz. właśnie zrobiłem dużo kopii i przeszłości. Użyj, Object.defineProperty(Array.prototype,...,writable:false,enumerable:false})jeśli chcesz utworzyć natywny prototyp. Przykład : https://stackoverflow.com/a/20463021/2450730

Demo http://jsfiddle.net/46S7g/

UWAGA: twoja stara tablica jest niszczona / staje się unikalna po tej operacji.

jeśli nie możesz odczytać powyższego kodu, zapytaj, przeczytaj książkę javascript lub oto wyjaśnienia dotyczące krótszego kodu. https://stackoverflow.com/a/21353032/2450730

niektórzy używają indexOf ... nie ... http://jsperf.com/dgfgghfghfghghgfhgfhfghfhgfh

dla pustych tablic

!array.length||toUnique(array); 

Wiele odpowiedzi tutaj może nie być przydatnych dla początkujących. Jeśli odkodowanie tablicy jest trudne, czy naprawdę będą wiedzieć o łańcuchu prototypów, a nawet o jQuery?

W nowoczesnych przeglądarkach czystym i prostym rozwiązaniem jest przechowywanie danych w zestawie , który ma być listą unikalnych wartości.

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

Array.fromJest przydatna do konwersji cofnięty do tablicy tak, że masz łatwy dostęp do wszystkich wspaniałych metod (cechy), które mają tablice. Istnieją również inne sposoby robienia tego samego. Ale może nie być wcale potrzebny Array.from, ponieważ zestawy mają wiele przydatnych funkcji, takich jak forEach .

Jeśli potrzebujesz obsługi starego programu Internet Explorer, a zatem nie możesz użyć zestawu, prostą techniką jest skopiowanie elementów do nowej tablicy, uprzednio sprawdzając, czy są już w nowej tablicy.

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

Aby umożliwić natychmiastowe ponowne użycie, włączmy funkcję.

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

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

        return result;
    }
}

Aby pozbyć się duplikatów, zrobilibyśmy to teraz.

var uniqueCars = deduplicate(cars);

deduplicate(cars)Część staje się rzeczą nazwaliśmy wynik gdy finalizuje funkcyjnych.

Po prostu podaj nazwę dowolnej tablicy, którą lubisz.

["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;
 }, []);

Możemy to zrobić za pomocą zestawów ES6:

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

console.log(uniqueArray);

// Wyjście będzie

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

Ten prototyp getUniquenie jest całkowicie poprawny, ponieważ jeśli mam tablicę typu: ["1",1,2,3,4,1,"foo"]zwróci ["1","2","3","4"]i "1"jest ciągiem i 1jest liczbą całkowitą; oni są różni.

Oto prawidłowe rozwiązanie:

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

za pomocą:

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

Powyższe spowoduje ["1",2,3,4,1,"foo"].

Bez rozszerzenia Array.prototype (mówi się, że jest to zła praktyka) lub użycia jquery / podkreślenia, możesz po prostu filtertablicę.

Zachowując ostatnie wystąpienie:

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

lub pierwsze wystąpienie:

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

Cóż, to tylko javascript ECMAScript 5+, co oznacza tylko IE9 +, ale jest przyjemny dla rozwoju w natywnym HTML / JS (aplikacja Windows Store, Firefox OS, Sencha, Phonegap, Titanium, ...).

magia

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

O (n) wydajność ; zakładamy, że twoja tablica jest w ai t={}. Objaśnienie tutaj (+ Jeppe impr.)

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)]

Jest to najprostszy i do którego odwołuje się dokument 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]

Jeśli używasz Prototype Framework, nie musisz wykonywać pętli „for”, możesz użyć http://www.prototypejs.org/api/array/uniq w następujący sposób:

var a = Array.uniq();  

Który wytworzy duplikat tablicy bez duplikatów. Natknąłem się na twoje pytanie, szukając metody zliczania różnych rekordów tablic, więc potem

uniq ()

użyłem

rozmiar()

i był mój prosty wynik. ps Przepraszam, jeśli coś źle wpisałem

edycja: jeśli chcesz uciec niezdefiniowanym rekordom, możesz je dodać

kompaktowy()

wcześniej, tak:

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

Teraz za pomocą zestawów możesz usunąć duplikaty i przekonwertować je z powrotem do tablicy.

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

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

Innym rozwiązaniem jest użycie sortowania i filtrowania

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

To dlatego, że 0jest to wartość fałsz w JavaScript.

this[i] będzie fałszem, jeśli wartość tablicy wynosi 0 lub dowolna inna wartość fałszowania.

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
}

Miałem nieco inny problem, w którym musiałem usunąć obiekty z duplikatami właściwości id z tablicy. to zadziałało.

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

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

console.log(objArr);

Najprostsza odpowiedź to:

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

Nie jestem pewien, dlaczego Gabriel Silveira napisał tę funkcję w ten sposób, ale prostsza forma, która działa dla mnie równie dobrze i bez minimalizacji, to:

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

lub w CoffeeScript:

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

Jeśli nie masz nic przeciwko dodatkowym zależnościom lub masz już jedną z bibliotek w bazie kodu, możesz usunąć duplikaty z tablicy za pomocą LoDash (lub Underscore).

Stosowanie

Jeśli nie masz go jeszcze w swojej bazie kodu, zainstaluj go za pomocą npm:

npm install lodash

Następnie użyj go w następujący sposób:

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

Na zewnątrz:

[ 1, 2, 3 ]

Odpowiedzi udzielono na wiele, ale nie zaspokoiło to mojej szczególnej potrzeby.

Wiele odpowiedzi jest takich:

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

Ale to nie działa w przypadku tablic złożonych obiektów.

Powiedzmy, że mamy taką tablicę:

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

Jeśli chcemy obiektów o unikalnych nazwach, powinniśmy użyć array.prototype.findIndexzamiast array.prototype.indexOf:

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

Od Shamasis Bhattacharya „s blog (O (2n) czasu złożoności):

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

Z bloga Paula Irisha : poprawa 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]

Znajdowanie unikalnych wartości tablic w prosty sposób

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]

Wygląda na to, że utraciliśmy odpowiedź Rafaela , która przez kilka lat stała się odpowiedzią przyjętą. Było to (przynajmniej w 2017 r.) Najskuteczniejsze rozwiązanie, jeśli nie masz tablicy typu mieszanego :

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

Jeśli zrobić posiada tablicę mieszany typu można szeregować klawisz skrótu:

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

Aby rozwiązać ten problem na odwrót, przydatne może być brak duplikatu podczas ładowania tablicy, tak jak zrobiłby to obiekt Set , ale nie jest jeszcze dostępny we wszystkich przeglądarkach. Oszczędza pamięć i jest bardziej wydajna, jeśli trzeba wielokrotnie przeglądać jej zawartość.

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

Próba:

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

Daje Ci set = [1,3,4,2]