Saya perlu memeriksa susunan JavaScript untuk melihat apakah ada nilai-nilai duplikat. Apa's cara termudah untuk melakukan hal ini? Aku hanya perlu menemukan apa yang digandakan nilai - I don't benar-benar membutuhkan indeks mereka atau berapa kali mereka digandakan.
Aku tahu aku bisa loop melalui array dan memeriksa semua nilai-nilai lain untuk pertandingan, tapi sepertinya harus ada cara yang lebih mudah.
Anda bisa mengurutkan array dan kemudian jalankan melalui itu dan kemudian melihat apakah berikutnya (atau sebelumnya) indeks ini sama seperti saat ini. Dengan asumsi semacam algoritma yang baik, ini harus kurang dari O(n2):
var arr = [9, 9, 111, 2, 3, 4, 4, 5, 7];
var sorted_arr = arr.slice().sort(); // You can define the comparing function here.
// JS by default uses a crappy string compare.
// (we use slice to clone the array so the
// original array won't be modified)
var results = [];
for (var i = 0; i < sorted_arr.length - 1; i++) {
if (sorted_arr[i + 1] == sorted_arr[i]) {
results.push(sorted_arr[i]);
}
}
console.log(results);
Dalam hal ini, jika anda ingin kembali sebagai fungsi untuk duplikat. Ini adalah jenis yang sama dari kasus ini.
Referensi: https://stackoverflow.com/a/57532964/8119511
Jika anda ingin elimate duplikat, coba ini solusi yang bagus:
function eliminateDuplicates(arr) {
var i,
len = arr.length,
out = [],
obj = {};
for (i = 0; i < len; i++) {
obj[arr[i]] = 0;
}
for (i in obj) {
out.push(i);
}
return out;
}
Sumber: http://dreaminginjavascript.wordpress.com/2008/08/22/eliminating-duplicates/
Ini adalah jawaban saya dari duplikat thread (!):
Saat menulis catatan ini 2014 - semua contoh yang bagi-loop atau jQuery. Javascript memiliki alat yang sempurna untuk ini: urutkan, peta dan mengurangi.
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 duplicates = Object.keys(uniq).filter((a) => uniq[a] > 1)
console.log(duplicates) // [ 'Nancy' ]
@Dmytro-Laptin menunjukkan beberapa kode kode yang akan dihapus. Ini adalah versi yang lebih kompak dari kode yang sama. Menggunakan beberapa ES6 trik dan tatanan yang lebih tinggi fungsi:
const names = ['Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Nancy', 'Carl']
const count = names =>
names.reduce((a, b) => ({ ...a,
[b]: (a[b] || 0) + 1
}), {}) // don't forget to initialize the accumulator
const duplicates = dict =>
Object.keys(dict).filter((a) => dict[a] > 1)
console.log(count(names)) // { Mike: 1, Matt: 1, Nancy: 2, Adam: 1, Jenny: 1, Carl: 1 }
console.log(duplicates(count(names))) // [ 'Nancy' ]
Ini harus menjadi salah satu cara terpendek untuk benar-benar menemukan nilai duplikat di array. Secara khusus diminta oleh OP, ini tidak menghapus duplikat tetapi menemukan mereka.
var input = [1, 2, 3, 1, 3, 1];
var duplicates = input.reduce(function(acc, el, i, arr) {
if (arr.indexOf(el) !== i && acc.indexOf(el) < 0) acc.push(el); return acc;
}, []);
document.write(duplicates); // = 1,3 (actual array == [1, 3])
Ini doesn't perlu menyortir atau pihak ketiga framework. Hal ini juga doesn't perlu manual loop. Ia bekerja dengan setiap nilai indexOf() (atau untuk lebih jelas: yang ketat perbandingan operator) mendukung.
Karena mengurangi() dan indexOf() hal ini membutuhkan setidaknya IE 9.
Anda dapat menambahkan fungsi ini, atau men-tweak itu dan menambahkannya ke Javascript's Array prototipe:
Array.prototype.unique = function () {
var r = new Array();
o:for(var i = 0, n = this.length; i < n; i++)
{
for(var x = 0, y = r.length; x < y; x++)
{
if(r[x]==this[i])
{
alert('this is a DUPE!');
continue o;
}
}
r[r.length] = this[i];
}
return r;
}
var arr = [1,2,2,3,3,4,5,6,2,3,7,8,5,9];
var unique = arr.unique();
alert(unique);
DIPERBARUI: berikut menggunakan aplikasi yang dioptimalkan strategi gabungan. Mengoptimalkan primitif pencarian untuk manfaat dari hash O(1) waktu pencarian (running unik
pada array primitif adalah O(n)). Objek pencarian yang dioptimalkan dengan penandaan benda dengan id unik saat iterasi melalui begitu mengidentifikasi duplikat benda-benda ini juga O(1) per item dan O(n) untuk seluruh daftar. Satu-satunya pengecualian adalah barang-barang yang beku, tetapi orang-orang yang langka dan mundur disediakan menggunakan array dan indexOf.
var unique = function(){
var hasOwn = {}.hasOwnProperty,
toString = {}.toString,
uids = {};
function uid(){
var key = Math.random().toString(36).slice(2);
return key in uids ? uid() : uids[key] = key;
}
function unique(array){
var strings = {}, numbers = {}, others = {},
tagged = [], failed = [],
count = 0, i = array.length,
item, type;
var id = uid();
while (i--) {
item = array[i];
type = typeof item;
if (item == null || type !== 'object' && type !== 'function') {
// primitive
switch (type) {
case 'string': strings[item] = true; break;
case 'number': numbers[item] = true; break;
default: others[item] = item; break;
}
} else {
// object
if (!hasOwn.call(item, id)) {
try {
item[id] = true;
tagged[count++] = item;
} catch (e){
if (failed.indexOf(item) === -1)
failed[failed.length] = item;
}
}
}
}
// remove the tags
while (count--)
delete tagged[count][id];
tagged = tagged.concat(failed);
count = tagged.length;
// append primitives to results
for (i in strings)
if (hasOwn.call(strings, i))
tagged[count++] = i;
for (i in numbers)
if (hasOwn.call(numbers, i))
tagged[count++] = +i;
for (i in others)
if (hasOwn.call(others, i))
tagged[count++] = others[i];
return tagged;
}
return unique;
}();
Jika anda memiliki ES6 Koleksi yang tersedia, maka ada yang jauh lebih sederhana dan secara signifikan lebih cepat versi. (shim untuk IE9+, dan browser lainnya di sini: https://github.com/Benvie/ES6-Harmony-Collections-Shim)
function unique(array){
var seen = new Set;
return array.filter(function(item){
if (!seen.has(item)) {
seen.add(item);
return true;
}
});
}
Ini harus membuat anda mendapatkan apa yang anda inginkan, Hanya duplikat.
function find_duplicates(arr) {
var len=arr.length,
out=[],
counts={};
for (var i=0;i<len;i++) {
var item = arr[i];
counts[item] = counts[item] >= 1 ? counts[item] + 1 : 1;
if (counts[item] === 2) {
out.push(item);
}
}
return out;
}
find_duplicates(['one',2,3,4,4,4,5,6,7,7,7,'pig','one']); // -> ['one',4,7] in no particular order.
DIPERBARUI: Pendek satu-liner untuk mendapatkan duplikat:
js [1, 2, 2, 4, 3, 4].filter((e, i, a) => a.indexOf(e) !== i) // [2, 4]
Untuk mendapatkan array tanpa duplikat hanya membalikkan kondisi:
js [1, 2, 2, 4, 3, 4].filter((e, i, a) => a.indexOf(e) === saya) // [1, 2, 3, 4]
Aku hanya tidak berpikir tentang filter()
di old jawaban di bawah ini ;)
Ketika semua yang anda butuhkan adalah untuk memeriksa bahwa tidak ada duplikat seperti yang diminta dalam pertanyaan anda dapat menggunakan every()
metode:
[1, 2, 3].every((e, i, a) => a.indexOf(e) === i) // true
[1, 2, 1].every((e, i, a) => a.indexOf(e) === i) // false
Perhatikan bahwa setiap()
doesn't bekerja untuk IE 8 dan di bawah.
Berikut ini adalah milikku sederhana dan satu line solusi.
Pencarian tidak unik elemen pertama, kemudian membuat menemukan hotel yang unik dengan penggunaan yang Ditetapkan.
Jadi kita memiliki array duplikat di akhir.
var array = [1, 2, 2, 3, 3, 4, 5, 6, 2, 3, 7, 8, 5, 22, 1, 2, 511, 12, 50, 22];
console.log([...new Set(
array.filter((value, index, self) => self.indexOf(value) !== index))]
);
var a = [324,3,32,5,52,2100,1,20,2,3,3,2,2,2,1,1,1].sort();
a.filter(function(v,i,o){return i&&v!==o[i-1]?v:0;});
atau ketika ditambahkan ke prototyp.rantai Array
//copy and paste: without error handling
Array.prototype.unique =
function(){return this.sort().filter(function(v,i,o){return i&&v!==o[i-1]?v:0;});}
Lihat di sini: https://gist.github.com/1305056
Ini adalah usulan saya (ES6):
let a = [1, 2, 3, 4, 2, 2, 4, 1, 5, 6]
let b = [...new Set(a.sort().filter((o, i) => o !== undefined && a[i + 1] !== undefined && o === a[i + 1]))]
// b is now [1, 2, 4]
Array.prototype.unique = function () {
var arr = this.sort(), i; // input must be sorted for this to work
for( i=arr.length; i--; )
arr[i] === arr[i-1] && arr.splice(i,1); // remove duplicate item
return arr;
}
var arr = [1,2,2,3,3,4,5,6,2,3,7,8,5,9],
arr2 = [1,2,511,12,50],
arr3 = [22],
unique = arr.concat(arr2, arr3).unique();
console.log(unique); // [22, 50, 12, 511, 2, 1, 9, 5, 8, 7, 3, 6, 4]
if (!Array.prototype.indexOf){
Array.prototype.indexOf = function(elt /*, from*/){
var len = this.length >>> 0;
var from = Number(arguments[1]) || 0;
from = (from < 0) ? Math.ceil(from) : Math.floor(from);
if (from < 0)
from += len;
for (; from < len; from++){
if (from in this && this[from] === elt)
return from;
}
return -1;
};
}
if( $.inArray(this[i], arr) == -1 )
var arr = [1,2,2,3,3,4,5,6,2,3,7,8,5,22],
arr2 = [1,2,511,12,50],
arr3 = [22],
unique;
// Combine all the arrays to a single one
unique = arr.concat(arr2, arr3);
// create a new (dirty) Array with only the unique items
unique = unique.map((item,i) => unique.includes(item, i+1) ? item : '' )
// Cleanup - remove duplicate & empty items items
unique = [...new Set(unique)].filter(n => n);
console.log(unique);
alih-alih menambahkan 'Array.prototipe.indexOf'
Cepat dan elegan-cara menggunakan es6 objek destructuring dan mengurangi
Ini berjalan dalam O(n) (1 iterasi lebih dari array) dan doesn't ulangi nilai-nilai yang muncul lebih dari 2 kali
const arr = ['hi', 'hi', 'hi', 'bye', 'bye', 'asd']
const {
dup
} = arr.reduce(
(acc, curr) => {
acc.items[curr] = acc.items[curr] ? acc.items[curr] += 1 : 1
if (acc.items[curr] === 2) acc.dup.push(curr)
return acc
}, {
items: {},
dup: []
},
)
console.log(dup)
// ['hi', 'bye']
Berikut ini's solusi yang paling sederhana yang bisa saya pikirkan:
`` const arr = [-1, 2, 2, 2, 0, 0, 0, 500, -1, 'a', 'a', 'a']
const disaring = arr.filter((el, index) => arr.indexOf(el) !== indeks) // => disaring = [ 2, 2, 0, 0, -1, 'a', 'a' ]
const duplikat = [...Set baru(disaring)]
konsol.log(duplikat) // => [ 2, 0, -1, 'a' ] ``
Yang's ini.
Catatan:
Ia bekerja dengan angka-angka termasuk 0
, string dan bilangan negatif misalnya -1
-
Pertanyaan yang berhubungan dengan: https://stackoverflow.com/questions/1960473
Asli array arr
yang diawetkan (filter
mengembalikan array baru bukan memodifikasi asli)
The disaring
array berisi semua duplikat; itu bisa juga mengandung lebih dari 1 nilai yang sama (misalnya disaring kami menginap di sini adalah[ 2, 2, 0, 0, -1, 'a', 'a' ]
)
Jika anda ingin mendapatkan hanya nilai-nilai yang digandakan (anda don't ingin memiliki beberapa duplikat dengan nilai yang sama), anda dapat menggunakan [...Set baru(disaring)]
(ES6 memiliki objek Set yang dapat menyimpan hanya nilai-nilai unik)
Semoga ini bisa membantu.
Kode sederhana dengan ES6 sintaks (return array diurutkan dari duplikat):
let duplicates = a => {d=[]; a.sort((a,b) => a-b).reduce((a,b)=>{a==b&&!d.includes(a)&&d.push(a); return b}); return d};
Bagaimana untuk menggunakan:
duplicates([1,2,3,10,10,2,3,3,10]);
Dengan ES6 (atau menggunakan Babel atau Typescipt) anda hanya dapat melakukan:
var duplicates = myArray.filter(i => myArray.filter(ii => ii === i).length > 1);
Berikut fungsi (variasi dari eliminateDuplicates fungsi yang sudah disebutkan) tampaknya untuk melakukan trik, kembali test2,1,7,5 untuk input ["test", "test2", "test2", 1, 1, 1, 2, 3, 4, 5, 6, 7, 7, 10, 22, 43, 1, 5, 8]
Perhatikan bahwa masalah adalah orang asing di JavaScript daripada di kebanyakan bahasa-bahasa lain, karena JavaScript array dapat menampung apa saja. Perhatikan bahwa solusi yang menggunakan sorting mungkin perlu untuk memberikan yang tepat fungsi sorting-aku ingin't mencoba rute itu belum.
Ini implementasi tertentu bekerja untuk (setidaknya) string dan angka.
function findDuplicates(arr) {
var i,
len=arr.length,
out=[],
obj={};
for (i=0;i<len;i++) {
if (obj[arr[i]] != null) {
if (!obj[arr[i]]) {
out.push(arr[i]);
obj[arr[i]] = 1;
}
} else {
obj[arr[i]] = 0;
}
}
return out;
}