Saya memiliki sangat sederhana JavaScript array yang mungkin atau mungkin tidak berisi duplikat.
var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];
Saya perlu untuk menghapus duplikat dan menempatkan nilai-nilai unik dalam sebuah array baru.
Aku bisa menunjukkan semua kode yang saya've mencoba tapi saya pikir itu's tidak berguna karena mereka don't bekerja. Saya menerima jQuery solusi juga.
Menggunakan Set konstruktor dan menyebar sintaks:
uniq = [...new Set(array)];
uniqueArray = a.filter(function(item, pos) {
return a.indexOf(item) == pos;
})
Pada dasarnya, kita iterate atas array dan, untuk masing-masing elemen, periksa apakah posisi pertama ini elemen dalam array adalah sama dengan posisi saat ini. Jelas, ini dua posisi yang berbeda untuk elemen duplikat. Menggunakan 3 ("array ini") parameter filter callback kita dapat menghindari penutupan variabel array:
uniqueArray = a.filter(function(item, pos, self) {
return self.indexOf(item) == pos;
})
function uniq(a) {
var seen = {};
return a.filter(function(item) {
return seen.hasOwnProperty(item) ? false : (seen[item] = true);
});
}
Ini adalah bagaimana hal itu's biasanya dilakukan. Idenya adalah untuk menempatkan setiap elemen dalam hashtable, dan kemudian memeriksa untuk kehadirannya langsung. Ini memberi kita waktu linier, tapi setidaknya memiliki dua kelemahan:
uniq([1,"1"])
akan kembali hanya [1]
uniq([{foo:1},{foo:2}])
akan kembali hanya [{foo:1}]
.
Yang mengatakan, jika anda array hanya berisi primitif dan anda don't peduli tentang jenis (misalnya's selalu angka), ini adalah solusi yang optimal.
Terbaik dari dua dunia Solusi universal menggabungkan kedua pendekatan: menggunakan hash pencarian untuk primitif dan linear mencari benda-benda.
function uniq(a) {
var prims = {"boolean":{}, "number":{}, "string":{}}, objs = [];
return a.filter(function(item) {
var type = typeof item;
if(type in prims)
return prims[type].hasOwnProperty(item) ? false : (prims[type][item] = true);
else
return objs.indexOf(item) >= 0 ? false : objs.push(item);
});
}
Pilihan lain adalah untuk mengurutkan array pertama, dan kemudian menghapus setiap elemen yang sama dengan sebelumnya:
function uniq(a) {
return a.sort().filter(function(item, pos, ary) {
return !pos || item != ary[pos - 1];
})
}
semacam
). Selain itu, kami diam-diam mengubah array asli sebagai efek samping - tidak baik! Namun, jika anda masukan sudah diurutkan, ini adalah cara untuk pergi (hanya menghapus semacam
dari atas).
Unik oleh... Kadang-kadang itu's yang diinginkan untuk uniquify daftar berdasarkan beberapa kriteria lain dari sekedar kesetaraan, misalnya, untuk menyaring benda-benda yang berbeda, tetapi berbagi beberapa properti. Hal ini dapat dilakukan secara elegan dengan melewati callback. Ini "kunci" callback diterapkan untuk masing-masing unsur, dan unsur-unsur yang sama dengan "tombol" dihapus. Sejak kunci
ini diharapkan untuk kembali primitif, tabel hash akan bekerja dengan baik di sini:
function uniqBy(a, key) {
var seen = {};
return a.filter(function(item) {
var k = key(item);
return seen.hasOwnProperty(k) ? false : (seen[k] = true);
})
}
Sangat berguna kunci()
adalah JSON.stringify
yang akan menghilangkan benda-benda yang secara fisik berbeda, tetapi "salah" sama:
a = [[1,2,3], [4,5,6], [1,2,3]]
b = uniqBy(a, JSON.stringify)
console.log(b) // [[1,2,3], [4,5,6]]
Jika kunci
ini tidak primitif, anda harus resor untuk pencarian linear:
function uniqBy(a, key) {
var index = [];
return a.filter(function (item) {
var k = key(item);
return index.indexOf(k) >= 0 ? false : index.push(k);
});
}
Di ES6 anda dapat menggunakan Set
:
function uniqBy(a, key) {
let seen = new Set();
return a.filter(item => {
let k = key(item);
return seen.has(k) ? false : seen.add(k);
});
}
atau sebuah Peta
:
function uniqBy(a, key) {
return [
...new Map(
a.map(x => [key(x), x])
).values()
]
}
Ketika menghapus objek dengan kunci, anda mungkin ingin menyimpan pertama dari "sama" benda-benda atau yang terakhir.
Gunakan Set
varian di atas untuk menjaga pertama, dan Peta
untuk menjaga lalu:
function uniqByKeepFirst(a, key) {
let seen = new Set();
return a.filter(item => {
let k = key(item);
return seen.has(k) ? false : seen.add(k);
});
}
function uniqByKeepLast(a, key) {
return [
...new Map(
a.map(x => [key(x), x])
).values()
]
}
//
data = [
{a:1, u:1},
{a:2, u:2},
{a:3, u:3},
{a:4, u:1},
{a:5, u:2},
{a:6, u:3},
];
console.log(uniqByKeepFirst(data, it => it.u))
console.log(uniqByKeepLast(data, it => it.u))
Kedua underscore dan Lo-Dash memberikan uniq
metode. Algoritma mereka pada dasarnya mirip dengan yang pertama cuplikan di atas dan didihkan bawah ini:
var result = [];
a.forEach(function(item) {
if(result.indexOf(item) < 0) {
result.push(item);
}
});
Ini adalah kuadrat, tapi ada tambahan yang bagus barang, seperti pembungkus asli indexOf
, kemampuan untuk uniqify oleh key (iteratee
dalam bahasa mereka), dan optimasi untuk yang telah diurutkan.
Jika anda're menggunakan jQuery dan dapat't berdiri apa-apa tanpa dolar sebelum itu, itu berjalan seperti ini:
$.uniqArray = function(a) {
return $.grep(a, function(item, pos) {
return $.inArray(item, a) === pos;
});
}
Fungsi panggilan mahal di JavaScript, oleh karena itu solusi di atas, seperti yang ringkas seperti mereka, tidak terlalu efisien. Untuk kinerja maksimal, ganti filter
dengan loop dan menyingkirkan lainnya fungsi panggilan:
function uniq_fast(a) {
var seen = {};
var out = [];
var len = a.length;
var j = 0;
for(var i = 0; i < len; i++) {
var item = a[i];
if(seen[item] !== 1) {
seen[item] = 1;
out[j++] = item;
}
}
return out;
}
Potongan ini jelek kode tidak sama seperti cuplikan #3 di atas, tetapi urutan besarnya lebih cepat (sebagai 2017 itu's hanya dua kali lebih cepat - JS inti orang-orang yang melakukan pekerjaan yang besar!)
function uniq(a) {
var seen = {};
return a.filter(function(item) {
return seen.hasOwnProperty(item) ? false : (seen[item] = true);
});
}
function uniq_fast(a) {
var seen = {};
var out = [];
var len = a.length;
var j = 0;
for(var i = 0; i < len; i++) {
var item = a[i];
if(seen[item] !== 1) {
seen[item] = 1;
out[j++] = item;
}
}
return out;
}
/////
var r = [0,1,2,3,4,5,6,7,8,9],
a = [],
LEN = 1000,
LOOPS = 1000;
while(LEN--)
a = a.concat(r);
var d = new Date();
for(var i = 0; i < LOOPS; i++)
uniq(a);
document.write('<br>uniq, ms/loop: ' + (new Date() - d)/LOOPS)
var d = new Date();
for(var i = 0; i < LOOPS; i++)
uniq_fast(a);
document.write('<br>uniq_fast, ms/loop: ' + (new Date() - d)/LOOPS)
ES6 menyediakan Set objek, yang membuat hal-hal jauh lebih mudah:
function uniq(a) {
return Array.from(new Set(a));
}
atau
let uniq = a => [...new Set(a)];
"malas", generator berbasis versi uniq
dapat dibangun atas dasar yang sama:
function* uniqIter(a) {
let seen = new Set();
for (let x of a) {
if (!seen.has(x)) {
seen.add(x);
yield x;
}
}
}
// example:
function* randomsBelow(limit) {
while (1)
yield Math.floor(Math.random() * limit);
}
// note that randomsBelow is endless
count = 20;
limit = 30;
for (let r of uniqIter(randomsBelow(limit))) {
console.log(r);
if (--count === 0)
break
}
// exercise for the reader: what happens if we set `limit` less than `count` and why
Bosan melihat semua contoh buruk dengan for-loop atau jQuery. Javascript memiliki alat yang sempurna untuk ini saat ini: urutkan, peta dan mengurangi.
var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];
var uniq = names.reduce(function(a,b){
if (a.indexOf(b) < 0 ) a.push(b);
return a;
},[]);
console.log(uniq, names) // [ 'Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Carl' ]
// one liner
return names.reduce(function(a,b){if(a.indexOf(b)<0)a.push(b);return a;},[]);
Mungkin ada cara yang lebih cepat tapi yang satu ini cukup layak.
var uniq = names.slice() // slice makes copy of array before sorting it
.sort(function(a,b){
return a > b;
})
.reduce(function(a,b){
if (a.slice(-1)[0] !== b) a.push(b); // slice(-1)[0] means last item in array without removing it (like .pop())
return a;
},[]); // this empty array becomes the starting value for a
// one liner
return names.slice().sort(function(a,b){return a > b}).reduce(function(a,b){if (a.slice(-1)[0] !== b) a.push(b);return a;},[]);
Di ES6 anda memiliki Set dan Penyebaran yang membuatnya sangat mudah dan performant untuk menghapus semua duplikat:
var uniq = [ ...new Set(names) ]; // [ 'Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Carl' ]
Seseorang bertanya tentang memesan hasil berdasarkan pada berapa banyak nama-nama yang unik ada:
var names = ['Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Nancy', 'Carl']
var uniq = names
.map((name) => {
return {count: 1, name: name}
})
.reduce((a, b) => {
a[b.name] = (a[b.name] || 0) + b.count
return a
}, {})
var sorted = Object.keys(uniq).sort((a, b) => uniq[a] < uniq[b])
console.log(sorted)
Vanilla JS: Menghapus duplikat menggunakan Objek seperti Set
Anda dapat selalu mencoba memasukkannya ke dalam sebuah objek, dan kemudian iterasi melalui tombol:
function remove_duplicates(arr) {
var obj = {};
var ret_arr = [];
for (var i = 0; i < arr.length; i++) {
obj[arr[i]] = true;
}
for (var key in obj) {
ret_arr.push(key);
}
return ret_arr;
}
Vanilla JS: Menghapus duplikat dengan pelacakan sudah melihat nilai-nilai (order-aman)
Atau, untuk perintah-versi aman, menggunakan sebuah objek untuk menyimpan semua sebelumnya terlihat nilai-nilai, dan nilai-nilai cek terhadap hal itu sebelum sebelum menambahkan ke sebuah array.
function remove_duplicates_safe(arr) {
var seen = {};
var ret_arr = [];
for (var i = 0; i < arr.length; i++) {
if (!(arr[i] in seen)) {
ret_arr.push(arr[i]);
seen[arr[i]] = true;
}
}
return ret_arr;
}
ECMAScript 6: Menggunakan Set data struktur (rangka-aman)
ECMAScript 6 menambahkan baru Set
Data-Struktur, yang memungkinkan anda untuk menyimpan nilai-nilai dari setiap jenis. Set.nilai-nilai
kembali unsur-unsur dalam urutan penyisipan.
function remove_duplicates_es6(arr) {
let s = new Set(arr);
let it = s.values();
return Array.from(it);
}
Contoh penggunaan:
a = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];
b = remove_duplicates(a);
// b:
// ["Adam", "Carl", "Jenny", "Matt", "Mike", "Nancy"]
c = remove_duplicates_safe(a);
// c:
// ["Mike", "Matt", "Nancy", "Adam", "Jenny", "Carl"]
d = remove_duplicates_es6(a);
// d:
// ["Mike", "Matt", "Nancy", "Adam", "Jenny", "Carl"]
It's perpustakaan dengan sejumlah fungsi untuk memanipulasi array.
It's dasi untuk pergi bersama dengan jQuery's tux, dan Punggung.js's suspender.
_.uniq(array, [isSorted], [iterator])
Alias: unik Menghasilkan duplikat-gratis versi hotel, menggunakan === untuk benda uji kesetaraan. Jika anda tahu sebelumnya bahwa hotel diurutkan, lewat benar untuk isSorted akan berjalan jauh lebih cepat algoritma. Jika anda ingin menghitung barang-barang yang unik didasarkan pada transformasi, lulus iterator fungsi.
[Contoh][3]
var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];
alert(_.uniq(names, false));
Catatan: Lo-Dash (an underscore pesaing) juga menawarkan sebanding .uniq implementasi.
Anda hanya dapat melakukannya dalam JavaScript, dengan bantuan kedua - index - parameter filter
metode:
var a = [2,3,4,5,5,4];
a.filter(function(value, index){ return a.indexOf(value) == index });
atau di tangan pendek
a.filter((v,i) => a.indexOf(v) == i)
Yang paling singkat cara menghapus duplikat dari array menggunakan native javascript fungsi adalah dengan menggunakan urutan seperti di bawah ini:
vals.sort().reduce(function(a, b){ if (b != a[0]) a.unshift(b); return a }, [])
ada's tidak perlu untuk iris
atau indexOf
dalam mengurangi fungsi, seperti saya've terlihat dalam contoh-contoh lain! masuk akal untuk menggunakannya bersama dengan fungsi filter meskipun:
vals.filter(function(v, i, a){ return i == a.indexOf(v) })
Namun lain ES6(2015) cara melakukan ini, yang sudah bekerja di beberapa browser adalah:
Array.from(new Set(vals))
atau bahkan menggunakan menyebar operator:
[...new Set(vals)]
cheers!
menggunakan
Array.filter()
seperti ini
var actualArr = ['Apple', 'Apple', 'Banana', 'Mango', 'Strawberry', 'Banana'];
console.log('Actual Array: ' + actualArr);
var filteredArr = actualArr.filter(function(item, index) {
if (actualArr.indexOf(item) == index)
return item;
});
console.log('Filtered Array: ' + filteredArr);
ini dapat dibuat lebih pendek di ES6 untuk
actualArr.filter((item,index,self) => self.indexOf(item)==index);
Di sini adalah baik penjelasan dari Array.filter()
Sederhana Satu I've lari ke sejauh ini. Di es6.
var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl", "Mike", "Nancy"]
var noDupe = Array.from(new Set(names))
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
Saya telah melakukan perbandingan rinci dari dupes penghapusan pada beberapa pertanyaan lain tapi setelah melihat bahwa ini adalah tempat yang nyata aku hanya ingin berbagi di sini juga.
Saya percaya ini adalah cara terbaik untuk melakukan hal ini
var myArray = [100, 200, 100, 200, 100, 100, 200, 200, 200, 200],
reduced = Object.keys(myArray.reduce((p,c) => (p[c] = true,p),{}));
console.log(reduced);
OK .. meskipun yang satu ini adalah O(n) dan lain-lain adalah O(n^2) saya penasaran untuk melihat patokan perbandingan antara ini mengurangi / look up table dan filter/indexOf combo (saya memilih Jeetendras sangat bagus implementasi https://stackoverflow.com/a/37441144/4543207). Aku mempersiapkan 100K item array diisi dengan sembarang bilangan bulat positif dalam berbagai 0-9999 dan dan menghilangkan duplikat. Saya ulangi tes untuk 10 kali dan rata-rata dari hasil penelitian menunjukkan bahwa mereka tidak cocok dalam kinerja.
Nah ok sejauh ini baik-baik. Tapi let's melakukannya dengan benar kali ini di ES6 gaya. Hal ini terlihat begitu keren..! Tapi sekarang cara itu akan tampil melawan yang kuat lut solusi adalah sebuah misteri bagi saya. Mari kita pertama melihat kode dan kemudian acuan itu.
var myArray = [100, 200, 100, 200, 100, 100, 200, 200, 200, 200],
reduced = [...myArray.reduce((p,c) => p.set(c,true),new Map()).keys()];
console.log(reduced);
Wow itu pendek..! Tapi bagaimana dengan kinerja..? It's indah... Karena berat dari filter / indexOf diangkat di atas bahu kita sekarang aku dapat menguji sebuah array 1M item acak dari bilangan bulat positif dalam rentang 0..99999 untuk mendapatkan rata-rata dari 10 tes berturut-turut. Yang bisa saya katakan saat ini's pertandingan nyata. Melihat hasil untuk diri sendiri :)
var ranar = [],
red1 = a => Object.keys(a.reduce((p,c) => (p[c] = true,p),{})),
red2 = a => reduced = [...a.reduce((p,c) => p.set(c,true),new Map()).keys()],
avg1 = [],
avg2 = [],
ts = 0,
te = 0,
res1 = [],
res2 = [],
count= 10;
for (var i = 0; i<count; i++){
ranar = (new Array(1000000).fill(true)).map(e => Math.floor(Math.random()*100000));
ts = performance.now();
res1 = red1(ranar);
te = performance.now();
avg1.push(te-ts);
ts = performance.now();
res2 = red2(ranar);
te = performance.now();
avg2.push(te-ts);
}
avg1 = avg1.reduce((p,c) => p+c)/count;
avg2 = avg2.reduce((p,c) => p+c)/count;
console.log("reduce & lut took: " + avg1 + "msec");
console.log("map & spread took: " + avg2 + "msec");
Mana yang akan anda gunakan..? Yah tidak begitu cepat...! Don't tertipu. Peta adalah perpindahan. Sekarang lihat... dalam semua kasus di atas kita isi array berukuran n dengan angka-angka dari berbagai < n. Maksud saya, kita memiliki sebuah array dari ukuran 100 dan kita isi dengan angka acak 0..9 jadi pasti ada duplikat dan "hampir" pasti setiap nomor memiliki duplikat. Bagaimana jika kita mengisi array dalam ukuran 100 dengan angka acak 0..9999. Let's sekarang lihat Peta bermain di rumah. Kali ini sebuah Array dari 100K barang-barang, tetapi nomor acak rentang 0..100M. Kami akan melakukan 100 berturut-tes untuk rata-rata hasil. OK let's melihat taruhan..! <- tidak ada typo
var ranar = [],
red1 = a => Object.keys(a.reduce((p,c) => (p[c] = true,p),{})),
red2 = a => reduced = [...a.reduce((p,c) => p.set(c,true),new Map()).keys()],
avg1 = [],
avg2 = [],
ts = 0,
te = 0,
res1 = [],
res2 = [],
count= 100;
for (var i = 0; i<count; i++){
ranar = (new Array(100000).fill(true)).map(e => Math.floor(Math.random()*100000000));
ts = performance.now();
res1 = red1(ranar);
te = performance.now();
avg1.push(te-ts);
ts = performance.now();
res2 = red2(ranar);
te = performance.now();
avg2.push(te-ts);
}
avg1 = avg1.reduce((p,c) => p+c)/count;
avg2 = avg2.reduce((p,c) => p+c)/count;
console.log("reduce & lut took: " + avg1 + "msec");
console.log("map & spread took: " + avg2 + "msec");
Sekarang ini adalah comeback spektakuler dari Peta()..! Mungkin sekarang anda dapat membuat keputusan yang lebih baik ketika anda ingin menghapus dupes.
Nah ok kita semua bahagia sekarang. Tapi peran utama selalu datang terakhir dengan tepuk tangan beberapa. Saya yakin beberapa dari anda bertanya-tanya apa yang Membedakan objek yang akan dilakukan. Sekarang bahwa sejak kami terbuka untuk ES6 dan kita tahu Peta adalah pemenang dari permainan sebelumnya mari kita bandingkan Peta dengan Ditetapkan sebagai final. Khas Real Madrid vs Barcelona game kali ini... atau itu? Let's melihat siapa yang akan memenangkan el classico :)
var ranar = [],
red1 = a => reduced = [...a.reduce((p,c) => p.set(c,true),new Map()).keys()],
red2 = a => Array.from(new Set(a)),
avg1 = [],
avg2 = [],
ts = 0,
te = 0,
res1 = [],
res2 = [],
count= 100;
for (var i = 0; i<count; i++){
ranar = (new Array(100000).fill(true)).map(e => Math.floor(Math.random()*10000000));
ts = performance.now();
res1 = red1(ranar);
te = performance.now();
avg1.push(te-ts);
ts = performance.now();
res2 = red2(ranar);
te = performance.now();
avg2.push(te-ts);
}
avg1 = avg1.reduce((p,c) => p+c)/count;
avg2 = avg2.reduce((p,c) => p+c)/count;
console.log("map & spread took: " + avg1 + "msec");
console.log("set & A.from took: " + avg2 + "msec");
Wow.. pria..! Nah tiba-tiba itu didn't berubah menjadi el classico di semua. Lebih seperti Barcelona FC melawan CA Osasuna :))
Solusi 1
Array.prototype.unique = function() {
var a = [];
for (i = 0; i < this.length; i++) {
var current = this[i];
if (a.indexOf(current) < 0) a.push(current);
}
return a;
}
Solusi 2 (menggunakan Set)
Array.prototype.unique = function() {
return Array.from(new Set(this));
}
Tes
var x=[1,2,3,3,2,1];
x.unique() //[1,2,3]
Kinerja
Ketika aku diuji baik pelaksanaan (dengan dan tanpa Set) untuk kinerja di chrome, saya menemukan bahwa satu dengan yang Ditetapkan jauh lebih cepat!
Array.prototype.unique1 = function() {
var a = [];
for (i = 0; i < this.length; i++) {
var current = this[i];
if (a.indexOf(current) < 0) a.push(current);
}
return a;
}
Array.prototype.unique2 = function() {
return Array.from(new Set(this));
}
var x=[];
for(var i=0;i<10000;i++){
x.push("x"+i);x.push("x"+(i+1));
}
console.time("unique1");
console.log(x.unique1());
console.timeEnd("unique1");
console.time("unique2");
console.log(x.unique2());
console.timeEnd("unique2");
Berikut adalah lebih dari 80% lebih cepat dari metode jQuery yang terdaftar (lihat tes di bawah). Itu adalah sebuah jawaban dari pertanyaan yang sama beberapa tahun yang lalu. Jika aku menemukan orang yang awalnya diusulkan ini saya akan posting kredit. JS murni.
var temp = {};
for (var i = 0; i < array.length; i++)
temp[array[i]] = true;
var r = [];
for (var k in temp)
r.push(k);
return r;
Saya kasus uji perbandingan: http://jsperf.com/remove-duplicate-array-tests
Atas jawaban memiliki kompleksitas dari O(n²)
, tapi hal ini dapat dilakukan dengan hanya O(n)
dengan menggunakan objek sebagai hash:
function getDistinctArray(arr) {
var dups = {};
return arr.filter(function(el) {
var hash = el.valueOf();
var isDup = dups[hash];
dups[hash] = true;
return !isDup;
});
}
Ini akan bekerja untuk string, angka, dan tanggal. Jika array berisi benda-benda, solusi di atas tidak't bekerja karena ketika dipaksa untuk string, mereka semua akan memiliki nilai "[object object]"
(atau sesuatu yang mirip) dan isn't cocok sebagai nilai pencarian. Anda bisa mendapatkan O(n)
implementasi untuk benda-benda dengan menetapkan bendera pada objek itu sendiri:
function getDistinctObjArray(arr) {
var distinctArr = arr.filter(function(el) {
var isDup = el.inArray;
el.inArray = true;
return !isDup;
});
distinctArr.forEach(function(el) {
delete el.inArray;
});
return distinctArr;
}
2019 edit: versi Modern dari JavaScript membuat ini jauh lebih mudah untuk memecahkan masalah. Menggunakan Set
akan bekerja, terlepas dari apakah anda array berisi objek, string, angka, atau jenis lainnya.
function getDistinctArray(arr) {
return [...new Set(arr)];
}
Implementasi ini sangat sederhana, mendefinisikan sebuah fungsi tidak lagi dibenarkan.
Dalam ECMAScript 6 (alias ECMAScript 2015), Set
dapat digunakan untuk menyaring duplikat. Kemudian dapat diubah kembali untuk sebuah array menggunakan menyebar operator.
var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"],
unique = [...new Set(names)];
Berikut ini adalah jawaban sederhana untuk pertanyaan.
var names = ["Alex","Tony","James","Suzane", "Marie", "Laurence", "Alex", "Suzane", "Marie", "Marie", "James", "Tony", "Alex"];
var uniqueNames = [];
for(var i in names){
if(uniqueNames.indexOf(names[i]) === -1){
uniqueNames.push(names[i]);
}
}
Sebuah teknik sederhana namun efektif, adalah dengan menggunakan filter
metode dalam kombinasi dengan filter fungsi(nilai indeks){ kembali this.indexOf(nilai) == index }
.
var data = [2,3,4,5,5,4]; var filter = function(value index){ kembali this.indexOf(nilai) == index }; var filteredData = data.filter(filter, data );
dokumen.tubuh.innerHTML = '
' + JSON.stringify(filteredData, null, '\t') + '';
Lihat juga [ini Biola][4].