Ho una serie di numeri che devo accertarmi che siano univoci. Ho trovato lo snippet di codice qui sotto su Internet e funziona benissimo fino a quando l'array non contiene uno zero. Ho trovato questo altro script qui su Stack Overflow che sembra quasi esattamente simile, ma non fallisce.

Quindi, per aiutarmi ad imparare, qualcuno può aiutarmi a determinare dove lo script del prototipo sta andando storto?

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

Altre risposte da una domanda duplicata:

• Rimuovere i valori duplicati dall'array JS

Domanda simile:

• Ottieni tutti i valori non univoci (ovvero: duplicato / più di un'occorrenza) in un array

Con JavaScript 1.6 / ECMAScript 5 è possibile utilizzare il filtermetodo nativo di un array nel modo seguente per ottenere un array con valori univoci:

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

Il metodo nativo filtereseguirà il ciclo nell'array e lascerà solo quelle voci che passano la data funzione di callback onlyUnique.

onlyUniquecontrolla, se il valore dato è il primo che si verifica. In caso contrario, deve essere un duplicato e non verrà copiato.

Questa soluzione funziona senza alcuna libreria aggiuntiva come jQuery o prototype.js.

Funziona anche con array con tipi di valore misti.

Per i vecchi browser (<ie9), che non supportano i metodi nativi filtere indexOfpuoi trovare soluzioni nella documentazione MDN per filter e indexOf .

Se si desidera mantenere l'ultima occorrenza di un valore, sostituire semplicemente indexOfcon lastIndexOf.

Con ES6 si potrebbe abbreviare a questo:

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

Grazie a Camilo Martin per il suggerimento nel commento.

ES6 ha un oggetto nativo Setper memorizzare valori univoci. Per ottenere un array con valori univoci, puoi fare ora questo:

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

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

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

Il costruttore di Setprende un oggetto iterabile, come Array, e l'operatore spread ...trasforma il set in un array. Grazie a Lukas Liese per il suggerimento nel commento.

Risposta aggiornata per ES6 / ES2015 : utilizzando il set , la soluzione a linea singola è:

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

Che ritorna

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

Come suggerito da le_m , questo può anche essere abbreviato usando l' operatore spread , come

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

Mi rendo conto che questa domanda ha già più di 30 risposte. Ma ho prima letto tutte le risposte esistenti e ho fatto le mie ricerche.

Ho diviso tutte le risposte a 4 possibili soluzioni:

1. Usa la nuova funzione ES6: [...new Set( [1, 1, 2] )];
2. Usa l'oggetto { }per prevenire i duplicati
3. Usa array di helper [ ]
4. Uso filter + indexOf

Ecco i codici di esempio trovati nelle risposte:

Usa la nuova funzione ES6: [...new Set( [1, 1, 2] )];

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

Usa l'oggetto { }per prevenire i duplicati

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

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

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

Usa array di helper [ ]

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

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

E mi chiedevo quale fosse più veloce. Ho realizzato un esempio di foglio di Google per testare le funzioni. Nota: ECMA 6 non è disponibile in Fogli Google, quindi non posso provarlo.

Ecco il risultato dei test:

Mi aspettavo di vedere che il codice usando l'oggetto { }vincerà perché usa l'hash. Quindi sono contento che i test abbiano mostrato i migliori risultati per questo algoritmo in Chrome e IE. Grazie a @rab per il codice .

Puoi anche usare underscore.js .

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

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

che restituirà:

[1, 2, 3, 4]

One Liner, JavaScript puro

Con sintassi 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")

Con sintassi ES5

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

Compatibilità del browser : IE9 +

Da allora ho trovato un bel metodo che utilizza jQuery

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

Nota: questo codice è stato estratto dal post di punzonatura delle anatre di Paul Irish - Ho dimenticato di dare credito: P

La soluzione più breve con ES6: [...new Set( [1, 1, 2] )];

O se si desidera modificare il prototipo dell'array (come nella domanda originale):

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

EcmaScript 6 è attualmente solo parzialmente implementato nei browser moderni (agosto 2015), ma Babel è diventato molto popolare per la traduzione di ES6 (e persino ES7) su ES5. In questo modo puoi scrivere il codice ES6 oggi!

Se ti stai chiedendo cosa ...significhi, si chiama operatore di diffusione . Da MDN : «L'operatore spread consente di espandere un'espressione in punti in cui sono previsti più argomenti (per chiamate di funzione) o più elementi (per valori letterali di array)». Poiché un set è iterabile (e può avere solo valori univoci), l'operatore spread espande il set per riempire l'array.

Risorse per l'apprendimento dell'ES6:

• Esplorando ES6 del Dr. Axel Rauschmayer
• Cerca "ES6" nelle newsletter settimanali di JS
• Articoli di approfondimento ES6 dal blog di Mozilla Hacks

La soluzione più semplice:

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

O:

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

Il modo più semplice e veloce (in Chrome) per farlo:

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

Esamina semplicemente ogni elemento dell'array, verifica se quell'elemento è già nell'elenco e, in caso contrario, passa all'array che viene restituito.

Secondo jsPerf, questa funzione è la più veloce di quelle che ho trovato ovunque : sentiti libero di aggiungere il tuo però.

La versione non prototipo:

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

Ordinamento

Quando è inoltre necessario ordinare l'array, il seguente è il più veloce:

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

o non prototipo:

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

Questo è anche più veloce del metodo sopra nella maggior parte dei browser non Chrome.

SOLO PERFORMANCE! questo codice è probabilmente 10 volte più veloce di tutti i codici qui * funziona su tutti i browser e ha anche il minor impatto di memoria .... e altro

se non hai bisogno di riutilizzare il vecchio array; btw fai le altre operazioni necessarie prima di convertirlo in unico qui è probabilmente il modo più veloce per farlo, anche molto breve.

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

allora puoi provare questo

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]

Mi è venuta in mente questa funzione leggendo questo articolo ...

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

Non mi piace il ciclo for. ha molti parametri. Mi piace il ciclo while--. mentre è il ciclo più veloce in tutti i browser tranne quello che a tutti noi piace così tanto ... Chrome.

comunque ho scritto la prima funzione che usa while. E sì, è un po 'più veloce della funzione trovata nell'articolo, ma non abbastanza.unique2()

il prossimo passo usa js moderni. Object.keys ho sostituito l'altro per loop con Object.keys di js1.7 ... un po 'più veloce e più corto (in chrome 2x più veloce);). Non abbastanza!. unique3().

a questo punto stavo pensando a ciò di cui ho veramente bisogno nella MIA funzione unica. non ho bisogno del vecchio array, voglio una funzione veloce. così ho usato 2 mentre loops + splice.unique4()

Inutile dire che sono rimasto colpito.

cromo: le solite 150.000 operazioni al secondo sono balzate a 1.800.000 operazioni al secondo.

vale a dire: 80.000 op / s contro 3.500.000 op / s

iOS: 18.000 op / s vs 170.000 op / s

safari: 80.000 op / s contro 6.000.000 op / s

Prova http://jsperf.com/wgu o meglio usa console.time ... microtime ... qualunque cosa

unique5() è solo per mostrarti cosa succede se vuoi mantenere il vecchio array.

Non usare Array.prototypese non sai cosa stai facendo. ho appena fatto un sacco di copia e passato. Utilizzare Object.defineProperty(Array.prototype,...,writable:false,enumerable:false})se si desidera creare un prototipo nativo.esempio : https://stackoverflow.com/a/20463021/2450730

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

NOTA: il tuo vecchio array viene distrutto / perché diventa unico dopo questa operazione.

se non riesci a leggere il codice sopra chiedi, leggi un libro javascript o qui ci sono alcune spiegazioni sul codice più breve. https://stackoverflow.com/a/21353032/2450730

alcuni stanno usando indexOf ... non ... http://jsperf.com/dgfgghfghfghghgfhgfhfghfhgfh

per array vuoti

!array.length||toUnique(array); 

Molte delle risposte qui potrebbero non essere utili ai principianti. Se il de-duping di un array è difficile, conosceranno davvero la catena di prototipi o persino jQuery?

Nei browser moderni, una soluzione semplice e pulita consiste nell'archiviare i dati in un set , progettato per essere un elenco di valori univoci.

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

Il Array.from è utile per convertire il set di nuovo a una matrice in modo da avere un facile accesso a tutti i metodi impressionante (caratteristiche) che gli array hanno. Ci sono anche altri modi per fare la stessa cosa. Ma potresti non averne bisogno Array.from, in quanto i set hanno molte funzioni utili come forOach .

Se è necessario supportare Internet Explorer precedente e quindi non è possibile utilizzare Set, una tecnica semplice consiste nel copiare gli elementi in un nuovo array verificando in anticipo se sono già nel nuovo array.

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

Per renderlo immediatamente riutilizzabile, mettiamolo in una funzione.

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

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

        return result;
    }
}

Quindi, per sbarazzarci dei duplicati, ora faremmo questo.

var uniqueCars = deduplicate(cars);

La deduplicate(cars)parte diventa l'elemento che abbiamo chiamato risultato al termine della funzione.

Basta passare il nome di qualsiasi array che ti piace.

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

Possiamo farlo usando i set ES6:

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

console.log(uniqueArray);

// L'output sarà

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

Questo prototipo getUniquenon è del tutto corretto, perché se ho un array come: ["1",1,2,3,4,1,"foo"]tornerà ["1","2","3","4"]ed "1"è una stringa ed 1è un numero intero; sono diversi.

Ecco una soluzione corretta:

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

utilizzando:

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

Quanto sopra produrrà ["1",2,3,4,1,"foo"].

Senza estendere Array.prototype (si dice che sia una cattiva pratica) o usare jquery / underscore, puoi semplicemente filterl'array.

Mantenendo l'ultima occorrenza:

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

o prima occorrenza:

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

Bene, è solo javascript ECMAScript 5+, che significa solo IE9 +, ma è bello per uno sviluppo in HTML / JS nativo (app di Windows Store, Firefox OS, Sencha, Phonegap, Titanium, ...).

Magia

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

O (n) prestazione ; supponiamo che il tuo array sia in ae t={}. Spiegazione qui (+ 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)]

Questo è il più semplice e referenziato da 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]

Se si utilizza il framework Prototype non è necessario eseguire i cicli 'for', è possibile utilizzare http://www.prototypejs.org/api/array/uniq in questo modo:

var a = Array.uniq();  

Che produrrà un array duplicato senza duplicati. Mi sono imbattuto nella tua domanda cercando un metodo per contare record di array distinti così dopo

uniq ()

ero solito

dimensione()

e c'era il mio semplice risultato. ps Scusami se ho sbagliato a scrivere qualcosa

modifica: se si desidera sfuggire ai record non definiti, è possibile che si desideri aggiungere

compatto()

prima, in questo modo:

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

Ora usando i set è possibile rimuovere i duplicati e convertirli nuovamente nella matrice.

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

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

Un'altra soluzione è utilizzare l'ordinamento e il filtro

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

Questo perché 0è un valore falso in JavaScript.

this[i] sarà falso se il valore della matrice è 0 o qualsiasi altro valore di falsa.

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
}

Ho avuto un problema leggermente diverso in cui avevo bisogno di rimuovere oggetti con proprietà ID duplicate da un array. questo ha funzionato.

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

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

console.log(objArr);

La risposta più semplice è:

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

Non sono sicuro del motivo per cui Gabriel Silveira abbia scritto la funzione in quel modo, ma una forma più semplice che funziona altrettanto bene per me e senza la minimizzazione è:

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

o in CoffeeScript:

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

Se stai bene con dipendenze extra, o hai già una delle librerie nella tua base di codice, puoi rimuovere i duplicati da un array sul posto usando LoDash (o Underscore).

uso

Se non lo hai già nel tuo codebase, installalo usando npm:

npm install lodash

Quindi usalo come segue:

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

Su:

[ 1, 2, 3 ]

Ciò ha ricevuto molte risposte, ma non ha soddisfatto il mio bisogno particolare.

Molte risposte sono così:

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

Ma questo non funziona per le matrici di oggetti complessi.

Supponiamo di avere un array come questo:

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

Se vogliamo gli oggetti con nomi univoci, dovremmo usare array.prototype.findIndexinvece di array.prototype.indexOf:

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

Da Shamasis Bhattacharya blog 's (O (2n) Tempo di complessità):

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

Dal blog di Paul Irish : miglioramento su 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]

Trovare valori di array univoci in un metodo semplice

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]

Sembra che abbiamo perso la risposta di Rafael , che è stata la risposta accettata per alcuni anni. Questa è stata (almeno nel 2017) la soluzione più performante se non si dispone di un array di tipo misto :

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

Se fare avere una matrice di tipo misto, è possibile serializzare il tasto cancelletto:

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

Per risolvere il problema viceversa, può essere utile non avere duplicati durante il caricamento dell'array, come farebbe Set object ma non è ancora disponibile in tutti i browser. Risparmia memoria ed è più efficiente se devi guardarne il contenuto più volte.

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

Campione:

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

Ti dà set = [1,3,4,2]