$(document).ready(function() { var arr1=["dog","dog","fish","cat","cat","fish","apple","orange"] var arr2=["cat","fish","mango","apple"] var uniquevalue=[]; var seconduniquevalue=[]; var finalarray=[]; $.each(arr1,function(key,value){ if($.inArray (value,uniquevalue) === -1) { uniquevalue.push(value) } }); $.each(arr2,function(key,value){ if($.inArray (value,seconduniquevalue) === -1) { seconduniquevalue.push(value) } }); $.each(uniquevalue,function(ikey,ivalue){ $.each(seconduniquevalue,function(ukey,uvalue){ if( ivalue == uvalue) { finalarray.push(ivalue); } }); }); alert(finalarray); });

Esta es probablemente una de las formas más rápidas de eliminar permanentemente los duplicados de una matriz 10 veces más rápido que la mayoría de las funciones aquí. Y 78 veces más rápido en safari

 function toUnique(a,b,c){ //array,placeholder,placeholder b=a.length;while(c=--b)while(c--)a[b]!==a[c]||a.splice(c,1) }

1. Prueba: http://jsperf.com/wgu
2. Demostración: http://jsfiddle.net/46S7g/
3. Más: https://stackoverflow.com/a/25082874/2450730

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

Otro método para hacer esto sin escribir mucho código es usar el método ES5 Object.keys :

 var arrayWithDuplicates = ['a','b','c','d','a','c'], deduper = {}; arrayWithDuplicates.forEach(function (item) { deduper[item] = null; }); var dedupedArray = Object.keys(deduper); // ["a", "b", "c", "d"]

Extraído en una función

 function removeDuplicates (arr) { var deduper = {} arr.forEach(function (item) { deduper[item] = null; }); return Object.keys(deduper); }

Aquí hay una respuesta simple a la pregunta.

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

En ECMAScript 6 (también conocido como ECMAScript 2015), Set se puede usar para filtrar duplicados. Luego se puede volver a convertir en una matriz utilizando el operador de propagación .

 var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"], unique = [...new Set(names)];

La forma más fácil de eliminar duplicados de cadenas es usar una matriz asociativa y luego iterar sobre la matriz asociativa para hacer que la lista/matriz vuelva.

Como abajo:

 var toHash = []; var toList = []; // add from ur data list to hash $(data.pointsToList).each(function(index, Element) { toHash[Element.nameTo]= Element.nameTo; }); // now convert hash to array // don't forget the "hasownproperty" else u will get random results for (var key in toHash) { if (toHash.hasOwnProperty(key)) { toList.push(toHash[key]); } }

¡Voila, ahora los duplicados se han ido!

La forma más sencilla de eliminar un duplicado es hacer un bucle for y comparar los elementos que no son iguales y colocarlos en la nueva matriz.

 var array = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"]; var removeDublicate = function(arr){ var result = [] var sort_arr = arr.sort() //=> optional for (var i = 0; i < arr.length; i++) { if(arr[ i + 1] !== arr[i] ){ result.push(arr[i]) } }; return result } console.log(removeDublicate(array)) ==> ["Adam", "Carl", "Jenny", "Matt", "Mike", "Nancy"]

Ve por este:

 var uniqueArray = duplicateArray.filter(function(elem, pos) { return duplicateArray.indexOf(elem) == pos; });

Ahora uniqueArray no contiene duplicados.

El siguiente script devuelve una nueva matriz que contiene solo valores únicos. Funciona en cadenas y números. No se requieren bibliotecas adicionales, solo Vanilla JS.

Compatibilidad con navegador:

 Feature Chrome Firefox (Gecko) Internet Explorer Opera Safari Basic support (Yes) 1.5 (1.8) 9 (Yes) (Yes)

https://jsfiddle.net/fzmcgcxv/3/

 var duplicates = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl","Mike","Mike","Nancy","Carl"]; var unique = duplicates.filter(function(elem, pos) { return duplicates.indexOf(elem) == pos; }); alert(unique);

Sé que llegué un poco tarde, pero aquí hay otra opción usando jinqJs

ver violín

 var result = jinqJs().from(["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"]).distinct().select();

Si por casualidad estuvieras usando

D3.js

Podrías hacerlo

 d3.set(["foo", "bar", "foo", "baz"]).values() ==> ["foo", "bar", "baz"]

https://github.com/mbostock/d3/wiki/Arrays#set_values

Método de bucle anidado para eliminar duplicados en una matriz y conservar el orden original de los elementos.

 var array = [1, 3, 2, 1, [5], 2, [4]]; // INPUT var element = 0; var decrement = array.length - 1; while(element < array.length) { while(element < decrement) { if (array[element] === array[decrement]) { array.splice(decrement, 1); decrement--; } else { decrement--; } } decrement = array.length - 1; element++; } console.log(array);// [1, 3, 2, [5], [4]]

Explicación: el ciclo interno compara el primer elemento de la matriz con todos los demás elementos, comenzando con el elemento en el índice más alto. Al disminuir hacia el primer elemento, se empalma un duplicado de la matriz.

Cuando finaliza el ciclo interno, el ciclo externo se incrementa al siguiente elemento para comparar y restablece la nueva longitud de la matriz.

Soluciones Vanilla JS con complejidad de O(n) (lo más rápido posible para este problema). Modifique hashFunction para distinguir los objetos (por ejemplo, 1 y "1") si es necesario. La primera solución evita bucles ocultos (común en las funciones proporcionadas por Array).

 var dedupe = function(a) { var hash={},ret=[]; var hashFunction = function(v) { return ""+v; }; var collect = function(h) { if(hash.hasOwnProperty(hashFunction(h)) == false) // O(1) { hash[hashFunction(h)]=1; ret.push(h); // should be O(1) for Arrays return; } }; for(var i=0; i<a.length; i++) // this is a loop: O(n) collect(a[i]); //OR: a.forEach(collect); // this is a loop: O(n) return ret; } var dedupe = function(a) { var hash={}; var isdupe = function(h) { if(hash.hasOwnProperty(h) == false) // O(1) { hash[h]=1; return true; } return false; }; return a.filter(isdupe); // this is a loop: O(n) }

https://jsfiddle.net/2w0k5tz8/

 function remove_duplicates(array_){ var ret_array = new Array(); for (var a = array_.length - 1; a >= 0; a--) { for (var b = array_.length - 1; b >= 0; b--) { if(array_[a] == array_[b] && a != b){ delete array_[b]; } }; if(array_[a] != undefined) ret_array.push(array_[a]); }; return ret_array; } console.log(remove_duplicates(Array(1,1,1,2,2,2,3,3,3)));

Recorra, elimine duplicados y cree un marcador de posición de matriz de clonación porque el índice de matriz no se actualizará.

Bucle hacia atrás para un mejor rendimiento (su bucle no necesitará seguir comprobando la longitud de su matriz)

La forma más concisa de eliminar duplicados de una matriz usando funciones javascript nativas es usar una secuencia como la siguiente:

 vals.sort().reduce(function(a, b){ if (b != a[0]) a.unshift(b); return a }, [])

no hay necesidad de slice ni indexOf dentro de la función de reducción, ¡como he visto en otros ejemplos! Sin embargo, tiene sentido usarlo junto con una función de filtro:

 vals.filter(function(v, i, a){ return i == a.indexOf(v) })

Otra forma ES6 (2015) de hacer esto que ya funciona en algunos navegadores es:

 Array.from(new Set(vals))

o incluso usando el operador de propagación :

 [...new Set(vals)]

¡salud!

Vanilla JS: eliminar duplicados usando un objeto como un conjunto

Siempre puede intentar ponerlo en un objeto y luego iterar a través de sus claves:

 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: elimine los duplicados mediante el seguimiento de los valores ya vistos (orden seguro)

O, para una versión segura de pedidos, use un objeto para almacenar todos los valores vistos anteriormente y verifique los valores antes de agregarlos a una matriz.

 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: use la nueva estructura de datos Set (seguro para pedidos)

ECMAScript 6 agrega el nuevo Set Data-Structure, que le permite almacenar valores de cualquier tipo. Set.values devuelve elementos en orden de inserción.

 function remove_duplicates_es6(arr) { let s = new Set(arr); let it = s.values(); return Array.from(it); }

Ejemplo de uso:

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

Rápido y sucio usando jQuery:

 var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"]; var uniqueNames = []; $.each(names, function(i, el){ if($.inArray(el, uniqueNames) === -1) uniqueNames.push(el); });

Usar subrayado.js

Es una biblioteca con una gran cantidad de funciones para manipular matrices.

Es la corbata que combina con el esmoquin de jQuery y los tirantes de Backbone.js.

_.uniq

_.uniq(array, [isSorted], [iterator]) Alias: único
Produce una versión sin duplicados de la matriz , usando === para probar la igualdad de objetos. Si sabe de antemano que la matriz está ordenada, pasar true para isSorted ejecutará un algoritmo mucho más rápido. Si desea calcular elementos únicos en función de una transformación, pase una función iteradora .

Ejemplo

 var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"]; alert(_.uniq(names, false));

Nota: Lo-Dash (un competidor de guión bajo ) también ofrece una implementación .uniq comparable.

El siguiente es más del 80 % más rápido que el método jQuery enumerado (consulte las pruebas a continuación). Es una respuesta de una pregunta similar hace unos años. Si me encuentro con la persona que lo propuso originalmente, publicaré los créditos. Puro JS.

 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;

Comparación de mi caso de prueba: http://jsperf.com/remove-duplicate-array-tests

Aquí hay otro enfoque usando jQuery,

 function uniqueArray(array){ if ($.isArray(array)){ var dupes = {}; var len, i; for (i=0,len=array.length;i<len;i++){ var test = array[i].toString(); if (dupes[test]) { array.splice(i,1); len--; i--; } else { dupes[test] = true; } } } else { if (window.console) console.log('Not passing an array to uniqueArray, returning whatever you sent it - not filtered!'); return(array); } return(array); }

Autor: William Skidmore

function removeDuplicates(inputArray) { var outputArray=new Array(); if(inputArray.length>0){ jQuery.each(inputArray, function(index, value) { if(jQuery.inArray(value, outputArray) == -1){ outputArray.push(value); } }); } return outputArray; }

Las respuestas principales tienen una complejidad de O(n²) , pero esto se puede hacer solo con O(n) usando un objeto como hash:

 function getDistinctArray(arr) { var dups = {}; return arr.filter(function(el) { var hash = el.valueOf(); var isDup = dups[hash]; dups[hash] = true; return !isDup; }); }

Esto funcionará para cadenas, números y fechas. Si su matriz contiene objetos, la solución anterior no funcionará porque cuando se coaccionan a una cadena, todos tendrán un valor de "[object Object]" (o algo similar) y eso no es adecuado como valor de búsqueda. Puede obtener una implementación de O(n) para objetos configurando un indicador en el objeto en sí:

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

Edición de 2019: las versiones modernas de JavaScript hacen que este problema sea mucho más fácil de resolver. El uso de Set funcionará, independientemente de si su matriz contiene objetos, cadenas, números o cualquier otro tipo.

 function getDistinctArray(arr) { return [...new Set(arr)]; }

La implementación es tan simple que ya no se garantiza la definición de una función.

Una versión de una sola línea que usa el filtro de matriz y la función indexOf:

 arr = arr.filter(function (value, index, array) { return array.indexOf(value) === index; });

Si no desea incluir una biblioteca completa, puede usar esta para agregar un método que cualquier matriz puede usar:

 Array.prototype.uniq = function uniq() { return this.reduce(function(accum, cur) { if (accum.indexOf(cur) === -1) accum.push(cur); return accum; }, [] ); } ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"].uniq()

Si está creando la matriz usted mismo, puede ahorrarse un bucle y el filtro único adicional haciendo la verificación mientras inserta los datos;

 var values = []; $.each(collection, function() { var x = $(this).value; if (!$.inArray(x, values)) { values.push(x); } });

Me cansé de ver todos los malos ejemplos con for-loops o jQuery. Javascript tiene las herramientas perfectas para esto hoy en día: ordenar, mapear y reducir.

Uniq reduce manteniendo el orden existente

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

Uniq más rápido con clasificación

Probablemente haya formas más rápidas, pero esta es bastante decente.

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

Actualización 2015: versión ES6:

En ES6 tiene Sets and Spread, lo que hace que sea muy fácil y eficiente eliminar todos los duplicados:

 var uniq = [ ...new Set(names) ]; // [ 'Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Carl' ]

Ordenar según la ocurrencia:

Alguien preguntó acerca de ordenar los resultados en función de cuántos nombres únicos hay:

 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)

Una ligera modificación de la excelente respuesta de thg435 para usar un comparador personalizado:

 function contains(array, obj) { for (var i = 0; i < array.length; i++) { if (isEqual(array[i], obj)) return true; } return false; } //comparator function isEqual(obj1, obj2) { if (obj1.name == obj2.name) return true; return false; } function removeDuplicates(ary) { var arr = []; return ary.filter(function(x) { return !contains(arr, x) && arr.push(x); }); }

El más simple con el que me he encontrado hasta ahora. En 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

var lines = ["Mike", "Matt", "Nancy", "Adam", "Jenny", "Nancy", "Carl"]; var uniqueNames = []; for(var i = 0; i < lines.length; i++) { if(uniqueNames.indexOf(lines[i]) == -1) uniqueNames.push(lines[i]); } if(uniqueNames.indexOf(uniqueNames[uniqueNames.length-1])!= -1) uniqueNames.pop(); for(var i = 0; i < uniqueNames.length; i++) { document.write(uniqueNames[i]); document.write("<br/>"); }

Rápido y fácil usando lodash - var array = ["12346","12347","12348","12349","12349"]; console.log(_.uniqWith(array,_.isEqual));

Entonces las opciones son:

 let a = [11,22,11,22]; let b = [] b = [ ...new Set(a) ]; // b = [11, 22] b = Array.from( new Set(a)) // b = [11, 22] b = a.filter((val,i)=>{ return a.indexOf(val)==i }) // b = [11, 22]

var uniqueCompnies = function(companyArray) { var arrayUniqueCompnies = [], found, x, y; for (x = 0; x < companyArray.length; x++) { found = undefined; for (y = 0; y < arrayUniqueCompnies.length; y++) { if (companyArray[x] === arrayUniqueCompnies[y]) { found = true; break; } } if ( ! found) { arrayUniqueCompnies.push(companyArray[x]); } } return arrayUniqueCompnies; } var arr = [ "Adobe Systems Incorporated", "IBX", "IBX", "BlackRock, Inc.", "BlackRock, Inc.", ];

aLinks es un simple objeto de matriz de JavaScript. Si existe algún elemento antes de los elementos en los que el índice muestra que se eliminó un registro duplicado. Repito para cancelar todos los duplicados. Una matriz de pasaje cancela más registros.

 var srt_ = 0; var pos_ = 0; do { var srt_ = 0; for (var i in aLinks) { pos_ = aLinks.indexOf(aLinks[i].valueOf(), 0); if (pos_ < i) { delete aLinks[i]; srt_++; } } } while (srt_ != 0);

Una técnica simple pero efectiva es usar el método de filter en combinación con la function(value, index){ return this.indexOf(value) == index } .

Ejemplo de código:

 var data = [2,3,4,5,5,4]; var filter = function(value, index){ return this.indexOf(value) == index }; var filteredData = data.filter(filter, data ); document.body.innerHTML = '<pre>' + JSON.stringify(filteredData, null, '\t') + '</pre>';

Véase también este Violín .

Solución 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; }

Solución 2 (usando Set)

 Array.prototype.unique = function() { return Array.from(new Set(this)); }

Prueba

 var x=[1,2,3,3,2,1]; x.unique() //[1,2,3]

Rendimiento

Cuando probé ambas implementaciones (con y sin Set) para el rendimiento en Chrome, ¡descubrí que la que tiene Set es mucho más rápida!

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

Esta solución utiliza una nueva matriz y un mapa de objetos dentro de la función. Todo lo que hace es recorrer la matriz original y agrega cada número entero al mapa de objetos. Si mientras recorre la matriz original se encuentra con una repetición, el

 `if (!unique[int])`

detecta esto porque ya hay una propiedad clave en el objeto con el mismo número. Por lo tanto, omitir ese número y no permitir que se inserte en la nueva matriz.

 function removeRepeats(ints) { var unique = {} var newInts = [] for (var i = 0; i < ints.length; i++) { var int = ints[i] if (!unique[int]) { unique[int] = 1 newInts.push(int) } } return newInts } var example = [100, 100, 100, 100, 500] console.log(removeRepeats(example)) // prints [100, 500]

Simplemente puede hacerlo en JavaScript, con la ayuda del segundo parámetro de índice del método de filter :

 var a = [2,3,4,5,5,4]; a.filter(function(value, index){ return a.indexOf(value) == index });

o en forma abreviada

 a.filter((v,i) => a.indexOf(v) == i)

const numbers = [1, 1, 2, 3, 4, 4]; function unique(array) { return array.reduce((a,b) => { let isIn = a.find(element => { return element === b; }); if(!isIn){ a.push(b); } return a; },[]); } let ret = unique(numbers); // [1, 2, 3, 4]

la forma de usar reducir y encontrar.

Aunque ES6 Solution es la mejor, estoy desconcertado de que nadie haya mostrado la siguiente solución:

 function removeDuplicates(arr){ o={} arr.forEach(function(e){ o[e]=true }) return Object.keys(o) }

Lo que hay que recordar aquí es que los objetos DEBEN tener claves únicas. Estamos explotando esto para eliminar todos los duplicados. Hubiera pensado que esta sería la solución más rápida (antes de ES6).

Sin embargo, tenga en cuenta que esto también ordena la matriz.

Una línea:

 let names = ['Mike','Matt','Nancy','Adam','Jenny','Nancy','Carl', 'Nancy']; let dup = [...new Set(names)]; console.log(dup);

aquí está el método simple sin bibliotecas especiales son funciones especiales,

 name_list = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"]; get_uniq = name_list.filter(function(val,ind) { return name_list.indexOf(val) == ind; }) console.log("Original name list:"+name_list.length, name_list) console.log("\n Unique name list:"+get_uniq.length, get_uniq)

usa Array.filter() como este

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

esto se puede hacer más corto en ES6 para

 actualArr.filter((item,index,self) => self.indexOf(item)==index);

Aquí hay una buena explicación de Array.filter()

ES2015, 1-liner, que se encadena bien con map , pero solo funciona para números enteros:

 [1, 4, 1].sort().filter((current, next) => current !== next)

[1, 4]

Para cualquiera que busque aplanar matrices con elementos duplicados en una matriz única:

 function flattenUniq(arrays) { var args = Array.prototype.slice.call(arguments); var array = [].concat.apply([], args) var result = array.reduce(function(prev, curr){ if (prev.indexOf(curr) < 0) prev.push(curr); return prev; },[]); return result; }

Enfoque Funcional Genérico

Aquí hay un enfoque genérico y estrictamente funcional con ES2015:

 // small, reusable auxiliary functions const apply = f => a => f(a); const flip = f => b => a => f(a) (b); const uncurry = f => (a, b) => f(a) (b); const push = x => xs => (xs.push(x), xs); const foldl = f => acc => xs => xs.reduce(uncurry(f), acc); const some = f => xs => xs.some(apply(f)); // the actual de-duplicate function const uniqueBy = f => foldl( acc => x => some(f(x)) (acc) ? acc : push(x) (acc) ) ([]); // comparators const eq = y => x => x === y; // string equality case insensitive :D const seqCI = y => x => x.toLowerCase() === y.toLowerCase(); // mock data const xs = [1,2,3,1,2,3,4]; const ys = ["a", "b", "c", "A", "B", "C", "D"]; console.log( uniqueBy(eq) (xs) ); console.log( uniqueBy(seqCI) (ys) );

Podemos derivar fácilmente unique de unqiueBy o usar la implementación más rápida utilizando Set s:

 const unqiue = uniqueBy(eq); // const unique = xs => Array.from(new Set(xs));

Beneficios de este enfoque:

• solución genérica mediante el uso de una función de comparación separada
• implementación declarativa y sucinta
• reutilización de otras funciones pequeñas y genéricas

Consideraciones de rendimiento

uniqueBy no es tan rápido como una implementación imperativa con bucles, pero es mucho más expresivo debido a su generidad.

Si identifica a uniqueBy como la causa de una penalización de rendimiento concreta en su aplicación, reemplácela con código optimizado. Es decir, escribe tu código primero de forma funcional y declarativa. Luego, siempre que encuentre problemas de rendimiento, intente optimizar el código en las ubicaciones que son la causa del problema.

Consumo de memoria y recolección de basura

uniqueBy utiliza mutaciones ( push(x) (acc) ) escondidas dentro de su cuerpo. Reutiliza el acumulador en lugar de tirarlo después de cada iteración. Esto reduce el consumo de memoria y la presión del GC. Dado que este efecto secundario está envuelto dentro de la función, todo lo que está afuera permanece puro.

Aquí hay un código muy simple para comprender y trabajar en cualquier lugar (incluso en PhotoshopScript). ¡Revisalo!

 var peoplenames = new Array("Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"); peoplenames = unique(peoplenames); alert(peoplenames); function unique(array){ var len = array.length; for(var i = 0; i < len; i++) for(var j = i + 1; j < len; j++) if(array[j] == array[i]){ array.splice(j,1); j--; len--; } return array; } //*result* peoplenames == ["Mike","Matt","Nancy","Adam","Jenny","Carl"]

function removeDuplicates (array) { var sorted = array.slice().sort() var result = [] sorted.forEach((item, index) => { if (sorted[index + 1] !== item) { result.push(item) } }) return result }

var duplicates = function(arr){ var sorted = arr.sort(); var dup = []; for(var i=0; i<sorted.length; i++){ var rest = sorted.slice(i+1); //slice the rest of array if(rest.indexOf(sorted[i]) > -1){//do indexOf if(dup.indexOf(sorted[i]) == -1) dup.push(sorted[i]);//store it in another arr } } console.log(dup); } duplicates(["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"]);

Esta fue solo otra solución pero diferente al resto.

 function diffArray(arr1, arr2) { var newArr = arr1.concat(arr2); newArr.sort(); var finalArr = []; for(var i = 0;i<newArr.length;i++) { if(!(newArr[i] === newArr[i+1] || newArr[i] === newArr[i-1])) { finalArr.push(newArr[i]); } } return finalArr; }

function arrayDuplicateRemove(arr){ var c = 0; var tempArray = []; console.log(arr); arr.sort(); console.log(arr); for (var i = arr.length - 1; i >= 0; i--) { if(arr[i] != tempArray[c-1]){ tempArray.push(arr[i]) c++; } }; console.log(tempArray); tempArray.sort(); console.log(tempArray); }

Además de ser una solución más simple y concisa que las respuestas actuales (menos las de ES6 que miran hacia el futuro), probé esto y también fue mucho más rápido:

 var uniqueArray = dupeArray.filter(function(item, i, self){ return self.lastIndexOf(item) == i; });

Una advertencia: Array.lastIndexOf() se agregó en IE9, por lo que si necesita ir más bajo que eso, deberá buscar en otro lado.

for (i=0; i<originalArray.length; i++) { if (!newArray.includes(originalArray[i])) { newArray.push(originalArray[i]); } }