Tengo una serie de números que necesito para asegurarme de que sean únicos. Encontré el fragmento de código a continuación en Internet y funciona muy bien hasta que la matriz tiene un cero. Encontré este otro script aquí en Stack Overflow que se ve casi exactamente igual, pero no falla.

Entonces, en aras de ayudarme a aprender, ¿alguien puede ayudarme a determinar dónde va mal el script prototipo?

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

Más respuestas de preguntas duplicadas:

• Eliminar valores duplicados de la matriz JS

Pregunta similar:

• Obtenga todos los valores no únicos (es decir, duplicados / más de una aparición) en una matriz

Con JavaScript 1.6 / ECMAScript 5 puede usar el filtermétodo nativo de una matriz de la siguiente manera para obtener una matriz con valores únicos:

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

El método nativo filterrecorrerá la matriz y dejará solo aquellas entradas que pasen la función de devolución de llamada dada onlyUnique.

onlyUniquecomprueba, si el valor dado es el primero que ocurre. De lo contrario, debe ser un duplicado y no se copiará.

Esta solución funciona sin ninguna biblioteca adicional como jQuery o prototype.js.

Funciona también para matrices con tipos de valores mixtos.

Para los navegadores antiguos (<ie9), que no admiten los métodos nativos filtery indexOfpuede encontrar soluciones alternativas en la documentación de MDN para filter e indexOf .

Si desea mantener la última aparición de un valor, simplemente reemplace indexOfpor lastIndexOf.

Con ES6 se podría acortar a esto:

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

Gracias a Camilo Martin por la pista en el comentario.

ES6 tiene un objeto nativo Setpara almacenar valores únicos. Para obtener una matriz con valores únicos, ahora puede hacer esto:

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

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

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

El constructor de Settoma un objeto iterable, como Array, y el operador de propagación ...transforma el conjunto nuevamente en un Array. Gracias a Lukas Liese por la pista en el comentario.

Respuesta actualizada para ES6 / ES2015 : Usando el Set , la solución de línea única es:

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

Que vuelve

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

Como le_m sugirió, esto también se puede acortar usando el operador de propagación , como

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

Me doy cuenta de que esta pregunta ya tiene más de 30 respuestas. Pero primero leí todas las respuestas existentes e hice mi propia investigación.

Dividí todas las respuestas a 4 posibles soluciones:

1. Use la nueva función ES6: [...new Set( [1, 1, 2] )];
2. Usar objeto { }para evitar duplicados
3. Usar matriz auxiliar [ ]
4. Utilizar filter + indexOf

Aquí hay ejemplos de códigos encontrados en las respuestas:

Use la nueva función ES6: [...new Set( [1, 1, 2] )];

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

Usar objeto { }para evitar duplicados

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

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

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

Usar matriz auxiliar [ ]

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

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

Y me preguntaba cuál es más rápido. Hice una muestra de Google Sheet para probar funciones. Nota: ECMA 6 no está disponible en Hojas de cálculo de Google, por lo que no puedo probarlo.

Aquí está el resultado de las pruebas:

Esperaba ver que el código que usa el objeto { }ganará porque usa hash. Así que me alegro de que las pruebas mostraron los mejores resultados para este algoritmo en Chrome e IE. Gracias a @rab por el código .

También puedes usar underscore.js .

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

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

que devolverá:

[1, 2, 3, 4]

One Liner, JavaScript puro

Con sintaxis 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 sintaxis ES5

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

Compatibilidad del navegador : IE9 +

Desde entonces he encontrado un buen método que usa jQuery

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

Nota: Este código fue retirado del puesto de perforación de pato de Paul Irish - Me olvidé de dar crédito: P

La solución más corta con ES6: [...new Set( [1, 1, 2] )];

O si desea modificar el prototipo de matriz (como en la pregunta original):

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

Por el momento, EcmaScript 6 solo se implementa parcialmente en los navegadores modernos (agosto de 2015), pero Babel se ha vuelto muy popular por trasladar ES6 (e incluso ES7) a ES5. ¡De esa manera puedes escribir el código ES6 hoy!

Si se pregunta qué ...significa, se llama operador de propagación . Desde MDN : «El operador de propagación permite que una expresión se expanda en lugares donde se esperan múltiples argumentos (para llamadas a funciones) o múltiples elementos (para literales de matriz)». Debido a que un conjunto es iterable (y solo puede tener valores únicos), el operador de expansión expandirá el conjunto para llenar la matriz.

Recursos para aprender ES6:

• Explorando ES6 por el Dr. Axel Rauschmayer
• Buscar "ES6" en los boletines semanales de JS
• Artículos detallados de ES6 del blog Mozilla Hacks

La solución más simple:

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

La forma más simple y rápida (en Chrome) de hacer esto:

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

Simplemente revisa todos los elementos de la matriz, comprueba si ese elemento ya está en la lista y, si no lo está, pasa a la matriz que se devuelve.

Según jsPerf, esta función es la más rápida de las que pude encontrar en cualquier lugar ; no obstante, siéntase libre de agregar la suya.

La versión no 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;
}

Clasificación

Cuando también se necesita ordenar la matriz, lo siguiente es lo más rápido:

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

Esto también es más rápido que el método anterior en la mayoría de los navegadores que no son de Chrome.

RENDIMIENTO SOLO! este código es probablemente 10 veces más rápido que todos los códigos aquí * funciona en todos los navegadores y también tiene el menor impacto en la memoria ... y más

si no necesita reutilizar la matriz anterior; por cierto, haga las otras operaciones necesarias antes de convertirla en única aquí, probablemente sea la forma más rápida de hacerlo, también muy breve.

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

entonces puedes probar esto

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]

Se me ocurrió esta función leyendo este artículo ...

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

No me gusta el bucle for. tiene muchos parámetros. Me gusta el bucle while. while es el bucle más rápido en todos los navegadores, excepto el que a todos nos gusta tanto ... Chrome.

de todos modos, escribí la primera función que usa while. Y sí, es un poco más rápido que la función encontrada en el artículo. pero no lo suficiente.unique2()

El siguiente paso es usar js modernos. Object.keys Reemplacé el otro bucle for con Object.keys de js1.7 ... un poco más rápido y más corto (en Chrome 2x más rápido);). ¡No es suficiente!. unique3().

En este punto estaba pensando en lo que realmente necesito en MI función única. No necesito la matriz anterior, quiero una función rápida. así que usé 2 while loops + splice.unique4()

Inútil decir que estaba impresionado.

cromo: las 150,000 operaciones habituales por segundo aumentaron a 1,800,000 operaciones por segundo.

es decir: 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

Prueba http://jsperf.com/wgu o mejor usa console.time ... microtime ... lo que sea

unique5() es solo para mostrarle lo que sucede si desea mantener la matriz anterior.

No lo uses Array.prototypesi no sabes lo que estás haciendo. Acabo de hacer un montón de copia y pasado. Úselo Object.defineProperty(Array.prototype,...,writable:false,enumerable:false})si desea crear un prototipo nativo. Ejemplo: https://stackoverflow.com/a/20463021/2450730

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

NOTA: su matriz anterior se destruye / se vuelve única después de esta operación.

si no puede leer el código anterior, pregunte, lea un libro de JavaScript o aquí hay algunas explicaciones sobre el código más corto. https://stackoverflow.com/a/21353032/2450730

algunos están usando indexOf ... no ... http://jsperf.com/dgfgghfghfghghgfhgfhfghfhgfh

para matrices vacías

!array.length||toUnique(array); 

Muchas de las respuestas aquí pueden no ser útiles para principiantes. Si la eliminación de la duplicación de una matriz es difícil, ¿sabrán realmente sobre la cadena de prototipos, o incluso sobre jQuery?

En los navegadores modernos, una solución limpia y simple es almacenar datos en un Conjunto , que está diseñado para ser una lista de valores únicos.

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

Esto Array.fromes útil para convertir el conjunto de nuevo a una matriz para que tenga fácil acceso a todos los métodos (características) increíbles que tienen las matrices. También hay otras formas de hacer lo mismo. Pero es posible que no necesite Array.fromnada, ya que los Sets tienen muchas características útiles como forEach .

Si necesita admitir Internet Explorer anterior y, por lo tanto, no puede usar Set, una técnica simple es copiar los elementos en una nueva matriz y verificar de antemano si ya están en la nueva matriz.

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

Para que esto sea reutilizable al instante, vamos a ponerlo en una función.

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

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

        return result;
    }
}

Entonces, para deshacernos de los duplicados, ahora haríamos esto.

var uniqueCars = deduplicate(cars);

La deduplicate(cars)parte se convierte en lo que llamamos resultado cuando se completa la función.

Simplemente pásele el nombre de cualquier matriz que desee.

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

Podemos hacer esto usando conjuntos ES6:

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

console.log(uniqueArray);

// La salida será

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

Este prototipo getUniqueno es totalmente correcto, porque si tengo una matriz como: ["1",1,2,3,4,1,"foo"]volverá ["1","2","3","4"]y "1"es una cadena y 1es un número entero; ellos son diferentes.

Aquí hay una solución correcta:

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

utilizando:

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

Lo anterior producirá ["1",2,3,4,1,"foo"].

Sin extender Array.prototype (se dice que es una mala práctica) o usar jquery / subrayado, puede simplemente filterla matriz.

Al mantener la última ocurrencia:

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

o primera aparición:

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

Bueno, es solo JavaScript ECMAScript 5+, lo que significa solo IE9 +, pero es bueno para un desarrollo en HTML / JS nativo (aplicación de la Tienda Windows, Firefox OS, Sencha, Phonegap, Titanium, ...).

magia

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

O (n) rendimiento ; asumimos que su matriz está en ay t={}. Explicación aquí (+ 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)]

Este es el más simple y referenciado de 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]

Si está utilizando Prototype framework, no es necesario hacer bucles 'for', puede usar http://www.prototypejs.org/api/array/uniq de esta manera:

var a = Array.uniq();  

Lo que producirá una matriz duplicada sin duplicados. Encontré su pregunta buscando un método para contar distintos registros de matriz, así que después

uniq ()

solía

Talla()

y ahí estaba mi resultado simple. PD Lo siento si me equivoqué algo

editar: si desea escapar de registros indefinidos, puede agregar

compacto()

antes, así:

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

Ahora, usando conjuntos, puede eliminar duplicados y convertirlos nuevamente a la matriz.

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

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

Otra solución es usar ordenar y filtrar

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

Eso es porque 0es un valor falso en JavaScript.

this[i] será falso si el valor de la matriz es 0 o cualquier otro valor falso.

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
}

Tuve un problema ligeramente diferente en el que necesitaba eliminar objetos con propiedades de identificación duplicadas de una matriz. Esto funcionó.

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 respuesta más simple es:

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

No estoy seguro de por qué Gabriel Silveira escribió la función de esa manera, pero una forma más simple que funciona para mí igual de bien y sin la minificación es:

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

o en CoffeeScript:

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

Si está de acuerdo con las dependencias adicionales, o si ya tiene una de las bibliotecas en su base de código, puede eliminar duplicados de una matriz en su lugar utilizando LoDash (o subrayado).

Uso

Si aún no lo tiene en su base de código, instálelo usando npm:

npm install lodash

Luego úsalo de la siguiente manera:

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

Fuera:

[ 1, 2, 3 ]

Esto ha sido respondido mucho, pero no atendió mi necesidad particular.

Muchas respuestas son así:

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

Pero esto no funciona para matrices de objetos complejos.

Digamos que tenemos una matriz como esta:

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

Si queremos los objetos con nombres únicos, deberíamos usar en array.prototype.findIndexlugar de array.prototype.indexOf:

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

De Shamasis Bhattacharya el blog 's (complejidad O (2n)):

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

Del blog de Paul Irish : mejora en 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]

Encontrar valores únicos de matriz en un método simple

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]

Parece que hemos perdido la respuesta de Rafael , que se mantuvo como la respuesta aceptada durante algunos años. Esta fue (al menos en 2017) la solución de mejor rendimiento si no tiene una matriz de tipo mixto :

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

Si hacer un arreglo de tipo mixto, puede serializar la tecla de almohadilla:

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

Para solucionar el problema al revés, puede ser útil no tener duplicados mientras carga su matriz, de la forma en que lo haría el objeto Set , pero aún no está disponible en todos los navegadores. Ahorra memoria y es más eficiente si necesita ver su contenido muchas veces.

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

Muestra:

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

Te dio set = [1,3,4,2]