Am nevoie pentru a verifica o matrice JavaScript pentru a vedea dacă există orice valori duplicate. Ce's cel mai simplu mod de a face acest lucru? Am nevoie doar pentru a găsi ceea ce valorile duplicate sunt - eu nu't nevoie de fapt lor de indici sau de câte ori acestea sunt duplicate.
Știu că pot buclă prin matrice și verificați toate celelalte valori pentru un meci, dar se pare ca acolo ar trebui să fie o cale mai ușoară.
Ati putea sorta matrice și apoi atunci a alerga prin ea și apoi a se vedea dacă următor (sau anterior) indicele este la fel ca cel actual. Presupunând că un fel de algoritm este bun, acest lucru ar trebui să fie mai mică decât 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);
În cazul în care, dacă sunteți de a reveni ca o funcție de duplicate. Aceasta este de tip similar de caz.
Referință: https://stackoverflow.com/a/57532964/8119511
Dacă doriți să elimate duplicate, încercați această soluție excelentă:
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;
}
Sursa: http://dreaminginjavascript.wordpress.com/2008/08/22/eliminating-duplicates/
Acesta este răspunsul meu la duplicat fir (!):
Când a scris această intrare 2014 - toate exemplele au fost de-bucle sau jQuery. Javascript are instrumentele perfecte pentru acest: fel, hartă și de a reduce.
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 subliniat unele cod fi eliminat. Aceasta este o versiune mai compactă din același cod. Folosind unele ES6 trucuri și funcții de ordin superior:
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' ]
Acest lucru ar trebui să fie una dintre cele mai scurte căi pentru a găsi de fapt, valorile duplicate într-o matrice. În special cerut de către OP, acest lucru nu elimina duplicate, dar le găsește.
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])
Asta nu't nevoie de sortare sau de orice terț-cadru. De asemenea, nu't nevoie de manual de bucle. Acesta funcționează cu orice valoare indexOf() (sau pentru a fi mai clară: stricte de comparatie operator) sprijină.
Pentru că a a reduce() și indexOf() este nevoie de cel puțin IE 9.
Puteți adăuga această funcție, sau tweak-l și adăugați-l la Javascript's Matrice prototip:
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);
ACTUALIZAT: următoarele foloseste un optimizat strategie combinată. Acesta optimizează primitive căutări pentru a beneficia de O hash(1) de căutare timp (de funcționare "unic" pe o serie de primitive este O(n)). Obiect căutări sunt optimizate prin marcarea obiectelor cu un id unic, în timp ce iterarea prin atât de identificare duplicat obiecte este, de asemenea, O(1) per articol și O(n) pentru întreaga listă. Singura excepție este reprezentată de elemente care sunt înghețate, dar acestea sunt rare și de o rezervă este asigurată folosind o matrice și 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;
}();
Dacă aveți ES6 Colecții disponibile, atunci nu este mult mai simplu și mult mai rapid versiune. (shim pentru IE9+ și alte browsere aici: 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;
}
});
}
Acest lucru ar trebui să obține ceea ce vrei, Doar duplicate.
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.
ACTUALIZAT: Scurt one-liner pentru a obține duplicate:
js [1, 2, 2, 4, 3, 4].filtru((e, i, o) => un.indexOf(e) !== i) // [2, 4]
Pentru a obține matrice fără duplicate pur și simplu inversa condiție:
js [1, 2, 2, 4, 3, 4].filtru((e, i, o) => un.indexOf(e) === am) // [1, 2, 3, 4]
Eu pur și simplu nu cred că despre filter()
în vechiul meu răspuns de mai jos ;)
Când tot ce ai nevoie este de a verifica că nu există duplicate după cum a cerut în această întrebare puteți utiliza every()
metoda:
[1, 2, 3].every((e, i, a) => a.indexOf(e) === i) // true
[1, 2, 1].every((e, i, a) => a.indexOf(e) === i) // false
Rețineți că
Aici este al meu simplu și o linie soluție.
Se caută nu elemente unice în primul rând, apoi face găsit serie unic, cu utilizarea de Set.
Deci avem matrice de duplicate în cele din urmă.
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;});
sau atunci când a fost adăugat la prototyp.lanțul de Matrice
//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;});}
Vezi aici: https://gist.github.com/1305056
Aceasta este propunerea mea (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);
în loc de a adăuga la 'Matrice.prototip.indexOf'
Rapid si elegant mod cu ajutorul es6 obiect de destructurare și de a reduce
Acesta rulează în O(n) (1 repetare pe serie) și nu't repeta valorile care apar mai mult de 2 ori
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']
Aici's cea mai simplă soluție m-am putut gândi:
`` const arr = [-1, 2, 2, 2, 0, 0, 0, 500, -1, 'o', 'un', 'un']
const filtrat = arr.filtru((el, index) => arr.indexOf(el) !== index) // => filtrată = [ 2, 2, 0, 0, -1, 'o', 'un' ]
const duplicate = [...Set nou(filtrat)]
console.log(duplicate) // => [ 2, 0, -1, 'o' ] ``
Ca's a.
Notă:
Acesta funcționează cu orice număr inclusiv 0
, siruri de caractere și numere negative de exemplu, -1
-
Intrebare legate de: https://stackoverflow.com/questions/1960473
Original matrice arr
este păstrată ("filtru" revine noua matrice în loc de a modifica original)
La "filtrate" matrice conține *toate * duplicate; - l poate** de asemenea, conține mai mult de 1 aceeași valoare (de exemplu noastre filtrate matrice de aici este[ 2, 2, 0, 0, -1, 'o', 'un' ]
)
Dacă doriți să obțineți doar valorile sunt duplicate (nu't doriți să aveți mai multe duplicate cu aceeași valoare) pe care le pot folosi[...Set nou(filtrat)]` (ES6 a unui obiect Set care poate stoca numai valori unice)
Sper că acest lucru vă ajută.
Cu ES6 (sau folosind Babel sau Typescipt), puteți face pur și simplu:
var duplicates = myArray.filter(i => myArray.filter(ii => ii === i).length > 1);
Următoarea funcție (o variație de eliminateDuplicates funcția de menționat deja) pare să facă truc, revenind test2,1,7,5 pentru intrare ["de testare", "test2", "test2", 1, 1, 1, 2, 3, 4, 5, 6, 7, 7, 10, 22, 43, 1, 5, 8]
Rețineți că problema este străin în JavaScript decât în multe alte limbi, pentru că o matrice JavaScript poate deține doar despre nimic. Rețineți că soluțiile care folosesc sortare s-ar putea nevoie pentru a oferi un caz, funcția de sortare-am't încercat ruta încă.
Acest lucru special, lucrari de punere în aplicare pentru (cel puțin) de siruri de caractere și numere.
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;
}