Benzersiz olduğundan emin olmak için gereken bir dizi sayı var. Aşağıdaki kod snippet'i internette buldum ve dizi içinde sıfır olana kadar harika çalışıyor. Bu diğer betiği neredeyse tamamen benzeyen Stack Overflow'da buldum , ancak başarısız değil.

Öyleyse öğrenmeme yardım etmek adına, biri prototip betiğinin nerede yanlış gittiğini belirlememe yardımcı olabilir mi?

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

Yinelenen sorudan daha fazla yanıt:

• JS dizisinden yinelenen değerleri kaldırma

Benzer soru:

• Bir dizide benzersiz olmayan tüm değerleri (örneğin: yinelenen / birden fazla tekrar) elde etme

İle JavaScript 1.6 / ECMAScript 5 Eğer yerli kullanabilirsiniz filterbenzersiz değerlere sahip bir dizi almak için şu şekilde bir Array yöntemini:

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

Yerel yöntem filterdizi içinde döngü yapar ve yalnızca belirli geri çağrı işlevini geçen girdileri bırakır onlyUnique.

onlyUniqueverilen değerin ilk gerçekleşip gerçekleşmediğini kontrol eder. Değilse, kopya olmalı ve kopyalanmayacaktır.

Bu çözüm, jQuery veya prototype.js gibi ek bir kitaplık olmadan çalışır.

Karışık değer türlerine sahip diziler için de çalışır.

Eski tarayıcılar için (<IE9), o doğal yöntemleri desteklemez filterve indexOfsizin için MDN belgelerinde çalışma arounds bulabilirsiniz filtresi ve indexOf .

Eğer bir değerin son oluşumunu korumak istiyorsanız, basit değiştirin indexOftarafından lastIndexOf.

ES6 ile bu kısaltılabilir:

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

Yorumdaki ipucu için Camilo Martin'e teşekkürler .

ES6'nın Setbenzersiz değerleri saklamak için yerel bir nesnesi vardır . Benzersiz değerlere sahip bir dizi elde etmek için şimdi bunu yapabilirsiniz:

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

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

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

Yapıcı, SetArray gibi yinelenebilir bir nesneyi alır ve forma operatörü ...seti tekrar Array'a dönüştürür. Yorumdaki ipucu için Lukas Liese'ye teşekkürler .

ES6 / ES2015 için cevap Güncelleme : kullanma Set , tek satır çözümdür:

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

Hangi döndürür

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

Gibi le_m önerdi, bu da kullanılarak kısaltılabilir yayılmış operatörü gibi,

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

Bu sorunun zaten 30'dan fazla cevabı olduğunu biliyorum. Ama önce mevcut tüm cevapları okudum ve kendi araştırmamı yaptım.

Tüm cevapları 4 olası çözüme böldüm:

1. Yeni ES6 özelliğini kullanın: [...new Set( [1, 1, 2] )];
2. { }Yinelemeleri önlemek için nesne kullanma
3. Yardımcı dizi kullan [ ]
4. kullanım filter + indexOf

Yanıtlarda bulunan örnek kodlar şunlardır:

Yeni ES6 özelliğini kullanın: [...new Set( [1, 1, 2] )];

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

{ }Yinelemeleri önlemek için nesne kullanma

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

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

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

Yardımcı dizi kullan [ ]

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

kullanım 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;
}

Hangisinin daha hızlı olduğunu merak ettim. Yaptığım Örnek Google Sheet testi işlevlerine. Not: ECMA 6, Google E-Tablolar'da mevcut değildir, bu yüzden test edemiyorum.

İşte testlerin sonucu:

{ }Hash kullandığı için nesne kullanarak kod kazanacağını görmeyi bekledim . Testlerin Chrome ve IE'de bu algoritma için en iyi sonuçları gösterdiğine sevindim. @Rab kodu için teşekkürler .

Underscore.js dosyasını da kullanabilirsiniz .

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

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

geri dönecek:

[1, 2, 3, 4]

Bir Astar, Saf JavaScript

ES6 sözdizimi ile

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 sözdizimi ile

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

Tarayıcı Uyumluluğu : IE9 +

O zamandan beri jQuery kullanan güzel bir yöntem buldum

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

Not: Bu kod Paul Irish'ın ördek delme direğinden alınmıştır - Kredi vermeyi unuttum: P

ES6 ile en kısa çözüm: [...new Set( [1, 1, 2] )];

Veya Array prototipini değiştirmek istiyorsanız (orijinal sorudaki gibi):

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

EcmaScript 6 şu anda modern tarayıcılarda sadece kısmen uygulanmaktadır (Ağustos 2015), ancak Babel ES6'yı (ve hatta ES7'yi) ES5'e geri aktarmak için çok popüler oldu. Bu şekilde bugün ES6 kodunu yazabilirsiniz!

Bunun ne ...anlama geldiğini merak ediyorsanız , buna yayılma operatörü denir . Gönderen MDN'yi : «yayılmış operatörü bir ifade ya (dizi sayılların) çoklu elemanlar (işlev çağrıları için) birden argümanlar beklenen yerlerde genişletilmiş sağlar». Bir Set yinelenebilir (ve yalnızca benzersiz değerlere sahip olabileceğinden) olduğundan, forma operatörü diziyi doldurmak için Set'i genişletir.

ES6 öğrenmek için kaynaklar:

• ES6'yı Keşfetme Dr. Axel Rauschmayer
• “ES6” ifadesini arayınJS haftalık bültenlerinden
• Mozilla Hacks blogundaki ES6 makaleleri

En basit çözüm:

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

Veya:

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

Bunu yapmanın en basit ve en hızlı (Chrome'da) yolu:

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

Basitçe dizideki her öğeyi geçer, o öğenin listede olup olmadığını test eder ve değilse, döndürülen diziye itin.

JsPerf'e göre, bu işlev her yerde bulabildiğim en hızlı işlevdir - kendinizinkini eklemekten çekinmeyin.

Prototip olmayan sürüm:

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

sınıflandırma

Diziyi sıralamak gerektiğinde, aşağıdakiler en hızlısıdır:

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

veya prototip olmayan:

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

Bu aynı zamanda çoğu krom olmayan tarayıcıda yukarıdaki yöntemden daha hızlıdır .

YALNIZCA PERFORMANS! Bu kod muhtemelen burada tüm kodlardan 10 kat daha hızlı * tüm tarayıcılarda çalışır ve aynı zamanda en düşük bellek etkisi vardır .... ve daha fazlası

eski diziyi yeniden kullanmanız gerekmiyorsa; btw, onu benzersiz hale dönüştürmeden önce gerekli diğer işlemleri yapın, muhtemelen bunu yapmanın en hızlı yolu, aynı zamanda çok kısa.

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

o zaman bunu deneyebilirsin

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]

Bu işlevi bu makaleyi okuyarak buldum ...

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

For döngüsünü sevmiyorum. birçok parametreye sahip. while döngüsü gibi. while, hepimizin çok sevdiği tarayıcı dışında tüm tarayıcılarda en hızlı döngü ... chrome.

Neyse ise while kullanan ilk işlevi yazdı.Ve evet bu makalede bulunan işlevden biraz daha hızlı. ama yeterli değil.unique2()

sonraki adım modern js kullanın. Object.keys i döngü için js1.7's Object.keys ile değiştirdi ... biraz daha hızlı ve daha kısa (krom 2x daha hızlı);). Yeterli değil!. unique3().

bu noktada benzersiz fonksiyonumda gerçekten neye ihtiyacım olduğunu düşünüyordum. eski dizi gerekmez, hızlı bir fonksiyon istiyorum. bu yüzden 2 döngüler + ekleme kullandım.unique4()

Etkilendiğimi söylemek işe yaramaz.

krom: Saniyede normal 150.000 işlem saniyede 1.800.000 işleme sıçradı.

yani: 80.000 op / s vs 3.500.000 op / s

ios: 18.000 op / s vs 170.000 op / s

safari: 80.000 op / s vs 6.000.000 op / s

Kanıt http://jsperf.com/wgu veya daha iyi bir kullanım console.time ... mikrotime ... her neyse

unique5() sadece eski diziyi korumak istiyorsanız ne olacağını göstermektir.

Ne Array.prototypeyaptığını bilmiyorsan kullanmayın . sadece bir sürü kopya ve geçmiş yaptım. Object.defineProperty(Array.prototype,...,writable:false,enumerable:false})Yerel bir prototip oluşturmak istiyorsanız kullanın. Örnek: https://stackoverflow.com/a/20463021/2450730

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

NOT: Bu işlemden sonra eski diziniz imha edilir / bildirilir.

yukarıdaki kodu okuyamazsanız, bir javascript kitabı okuyun veya daha kısa kod hakkında bazı açıklamalar. https://stackoverflow.com/a/21353032/2450730

bazıları kullanıyor indexOf ... yapma ... http://jsperf.com/dgfgghfghfghghgfhgfhfghfhgfh

boş diziler için

!array.length||toUnique(array); 

Buradaki cevapların çoğu yeni başlayanlar için yararlı olmayabilir. Bir dizinin kaldırılması zorsa, prototip zinciri, hatta jQuery hakkında gerçekten bilgi sahibi olacaklar mı?

Modern tarayıcılarda, temiz ve basit bir çözüm, verileri benzersiz değerlerin bir listesi olarak tasarlanmış bir Sette saklamaktır .

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

Dizinin Array.fromsahip olduğu tüm harika yöntemlere (özelliklere) kolayca erişebilmeniz için Set'i bir Diziye dönüştürmek yararlıdır. Aynı şeyi yapmanın başka yolları da vardır . Ancak Array.fromSetler, forEach gibi birçok yararlı özelliğe sahip olduğundan, hiç ihtiyacınız olmayabilir .

Eski Internet Explorer'ı desteklemeniz gerekiyorsa ve bu nedenle Set'i kullanamıyorsanız, basit bir teknik, önceden yeni dizide olup olmadıklarını kontrol ederken öğeleri yeni bir diziye kopyalamaktır.

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

Bunu anında yeniden kullanılabilir hale getirmek için bir fonksiyona koyalım.

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

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

        return result;
    }
}

Yani kopyalardan kurtulmak için şimdi bunu yapardık.

var uniqueCars = deduplicate(cars);

deduplicate(cars)Parçası haline gelir biz adlandırılmış şey sonuç ne zaman fonksiyon tamamlamalar.

Sadece istediğiniz herhangi bir dizinin adını iletin.

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

Bunu ES6 setlerini kullanarak yapabiliriz:

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

console.log(uniqueArray);

// Çıktı

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

Bu prototip getUniquetamamen doğru değil, çünkü i gibi bir Array varsa: ["1",1,2,3,4,1,"foo"]dönecek ["1","2","3","4"]ve "1"dize ve 1bir tamsayı; onlar farklı.

İşte doğru bir çözüm:

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

kullanarak:

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

Yukarıdakiler üretecektir ["1",2,3,4,1,"foo"].

Array.prototype (kötü bir uygulama olduğu söylenir) veya jquery / alt çizgi kullanmadan filter, diziyi basitçe yapabilirsiniz .

Son olayı koruyarak:

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

veya ilk olay:

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

Eh, sadece javascript ECMAScript 5+, yani sadece IE9 + anlamına geliyor, ancak yerel HTML / JS'de (Windows Store Uygulaması, Firefox OS, Sencha, Phonegap, Titanium, ...) bir geliştirme için güzel.

sihirli

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

O (n) performans ; dizinizin ave içinde olduğunu varsayalım t={}. Burada açıklama (+ Jeppe göstr.)

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

Bu en basit olanıdır ve MDN Web Docs'tan alınmıştır .

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]

Prototip çerçevesini kullanıyorsanız 'for' döngülerine gerek yoktur, http://www.prototypejs.org/api/array/uniq'i şu şekilde kullanabilirsiniz :

var a = Array.uniq();  

Hangi yinelenen ile yinelenen bir dizi üretecektir. Sorunuzla, farklı dizi kayıtlarını saymak için bir yöntem ararken karşılaştım.

uniq ()

kullandım

boyut()

ve basit bir sonucum vardı. ps Özür dilerim bir şey yanlış

edit: tanımlanmamış kayıtlardan kaçmak istiyorsanız, eklemek isteyebilirsiniz

kompakt()

önce, böyle:

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

Şimdi kümeleri kullanarak kopyaları kaldırabilir ve diziye geri dönüştürebilirsiniz.

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

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

Başka bir çözüm, sıralama ve filtreyi kullanmaktır

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

Bunun nedeni 0JavaScript'teki yanlış bir değerdir.

this[i] dizinin değeri 0 veya başka herhangi bir falsy değeri ise falsy olur.

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
}

Ben bir diziden yinelenen kimlik özellikleri ile nesneleri kaldırmak için gerekli biraz farklı bir sorun vardı. bu işe yaradı.

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

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

console.log(objArr);

En basit cevap:

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

Gabriel Silveira'nın işlevi neden bu şekilde yazdığından emin değilim ama benim için de ve minimizasyon olmadan çalışan daha basit bir form:

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

veya CoffeeScript'te:

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

Ekstra bağımlılıklar konusunda sorun yaşıyorsanız veya kod tabanınızdaki kitaplıklardan birine zaten sahipseniz, LoDash'i (veya Alt Çizgi'yi) kullanarak bir diziden yinelenenleri kaldırabilirsiniz.

kullanım

Kod tabanınızda zaten yoksa npm kullanarak yükleyin:

npm install lodash

Sonra aşağıdaki gibi kullanın:

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

Dışarı:

[ 1, 2, 3 ]

Bu çok cevaplandı, ama benim özel ihtiyacımı karşılamadı.

Birçok cevap şöyle:

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

Ancak bu karmaşık nesnelerin dizileri için geçerli değildir.

Diyelim ki böyle bir dizimiz var:

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

Biz benzersiz adlarla nesneler istiyorsak, kullanmalısınız array.prototype.findIndexyerine array.prototype.indexOf:

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

Gönderen Shamasis Bhattacharya blogu (O (2n) zaman karmaşıklığı):

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

Gönderen Paul İrlanda bireyin blog JQuery üzerinde iyileştirme: .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]

Basit yöntemle benzersiz Dizi değerleri bulma

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]

Görünüşe göre Rafael'in cevabını kaybettik , birkaç yıldır kabul edilen cevap olarak kaldı. Karışık tip bir diziniz yoksa bu (en azından 2017'de) en iyi performans gösteren çözümdü :

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

Eğer varsa yapmak karışık tip dizi var, karma anahtarını serileştirebilirsiniz:

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

Sorunu başka bir şekilde gidermek için, dizinizi yüklerken, Set nesnesinin yaptığı gibi yinelenen herhangi bir şeyin olmaması yararlı olabilir, ancak henüz tüm tarayıcılarda kullanılamaz. Bellek tasarrufu sağlar ve içeriğine birçok kez bakmanız gerektiğinde daha verimlidir.

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

Örneklem:

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

Sana verir set = [1,3,4,2]