Eu tenho uma matriz de números que eu preciso ter certeza de que são únicos. Encontrei o trecho de código abaixo na internet e ele funciona muito bem até que o array tenha zero. Encontrei esse outro script aqui no Stack Overflow que se parece quase exatamente com ele, mas não falha.

Então, para me ajudar a aprender, alguém pode me ajudar a determinar onde o script do protótipo está errado?

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

Mais respostas da pergunta duplicada:

• Remova valores duplicados da matriz JS

Pergunta semelhante:

• Obter todos os valores não exclusivos (por exemplo: duplicado / mais de uma ocorrência) em uma matriz

Com o JavaScript 1.6 / ECMAScript 5, você pode usar o filtermétodo nativo de uma matriz da seguinte maneira para obter uma matriz com valores exclusivos:

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

O método nativo filterpercorrerá a matriz e deixará apenas as entradas que passam pela função de retorno de chamada fornecida onlyUnique.

onlyUniqueverifica se o valor fornecido é o primeiro a ocorrer. Caso contrário, deve ser uma duplicata e não será copiada.

Esta solução funciona sem nenhuma biblioteca extra como jQuery ou prototype.js.

Também funciona para matrizes com tipos de valor misto.

Para navegadores antigos (<IE9), que não suportam os métodos nativos filtere indexOfpode encontrar arounds trabalho na documentação MDN para filtro e indexOf .

Se você deseja manter a última ocorrência de um valor, substitua-o indexOfpor lastIndexOf.

Com o ES6, pode ser reduzido para isso:

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

Obrigado a Camilo Martin pela dica no comentário.

O ES6 possui um objeto nativo Setpara armazenar valores exclusivos. Para obter uma matriz com valores exclusivos, você pode fazer isso agora:

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

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

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

O construtor de Setpega um objeto iterável, como Matriz, e o operador de dispersão ...transforma o conjunto novamente em uma Matriz. Obrigado a Lukas Liese pela dica no comentário.

Resposta atualizada para ES6 / ES2015 : Usando o conjunto , a solução de linha única é:

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

Que retorna

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

Como le_m sugeriu, isso também pode ser reduzido usando o operador spread , como

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

Sei que esta pergunta já tem mais de 30 respostas. Mas li todas as respostas existentes primeiro e fiz minha própria pesquisa.

Dividi todas as respostas para 4 soluções possíveis:

1. Use o novo recurso ES6: [...new Set( [1, 1, 2] )];
2. Use objeto { }para evitar duplicatas
3. Usar matriz auxiliar [ ]
4. Usar filter + indexOf

Aqui estão exemplos de códigos encontrados nas respostas:

Use o novo recurso ES6: [...new Set( [1, 1, 2] )];

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

Use objeto { }para evitar duplicatas

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

Usar 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 me perguntei qual é o mais rápido. Fiz uma amostra do Google Sheet para testar funções. Nota: O ECMA 6 não está disponível no Planilhas Google, então não posso testá-lo.

Aqui está o resultado dos testes:

Eu esperava ver que o código usando o objeto { }vencerá porque ele usa hash. Estou feliz que os testes tenham mostrado melhores resultados para esse algoritmo no Chrome e no IE. Obrigado a @rab pelo código .

Você também pode usar underscore.js .

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

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

que retornará:

[1, 2, 3, 4]

One Liner, JavaScript puro

Com sintaxe 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")

Com sintaxe ES5

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

Compatibilidade do Navegador : IE9 +

Desde então, encontrei um bom método que usa jQuery

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

Nota: Este código foi retirado do post de soco de pato de Paul Irish - eu esqueci de dar crédito: P

Solução mais curta com ES6: [...new Set( [1, 1, 2] )];

Ou se você deseja modificar o protótipo Array (como na pergunta original):

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

No momento, o EcmaScript 6 é implementado apenas parcialmente em navegadores modernos (agosto de 2015), mas o Babel se tornou muito popular ao transpilar o ES6 (e até o ES7) de volta para o ES5. Dessa forma, você pode escrever o código ES6 hoje!

Se você está se perguntando o que isso ...significa, é chamado de operador de propagação . No MDN : «O operador spread permite que uma expressão seja expandida em locais onde são esperados múltiplos argumentos (para chamadas de função) ou múltiplos elementos (para literais de matriz)». Como um conjunto é iterável (e pode ter apenas valores exclusivos), o operador de expansão expandirá o conjunto para preencher a matriz.

Recursos para aprender ES6:

• Explorando o ES6 do Dr. Axel Rauschmayer
• Pesquise “ES6” nos boletins semanais da JS
• Artigos detalhados do ES6 do blog Mozilla Hacks

Solução mais simples:

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

Ou:

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

A maneira mais simples e rápida (no Chrome) de fazer isso:

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

Simplesmente percorre todos os itens da matriz, testa se esse item já está na lista e, se não estiver, envie para a matriz retornada.

De acordo com o jsPerf, essa função é a mais rápida que encontrei em qualquer lugar - fique à vontade para adicionar a sua.

A versão sem protótipo:

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

Ordenação

Quando também é necessário classificar a matriz, o seguinte é o mais 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;
}

ou não protótipo:

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

Isso também é mais rápido que o método acima na maioria dos navegadores não-chrome.

SOMENTE DESEMPENHO! esse código é provavelmente 10 vezes mais rápido que todos os códigos aqui * funciona em todos os navegadores e também tem o menor impacto na memória .... e mais

se você não precisar reutilizar o array antigo, faça as outras operações necessárias antes de convertê-lo em exclusivo aqui, provavelmente é a maneira mais rápida de fazer isso, também muito curta.

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

então você pode tentar isso

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]

Eu vim com essa função lendo este artigo ...

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

Eu não gosto do loop for. ele tem muitos parâmetros. eu gosto do loop while--. enquanto é o loop mais rápido em todos os navegadores, exceto no que todos gostamos tanto ... chrome.

de qualquer maneira eu escrevi a primeira função que usa while.E sim, é um pouco mais rápido que a função encontrada no article.but não é suficiente.unique2()

próximo passo use js modernos. Object.keys Substituí o outro por loop com Object.keys do js1.7 ... um pouco mais rápido e mais curto (no chrome 2x mais rápido);). Insuficiente!. unique3().

Neste ponto, eu estava pensando sobre o que eu realmente preciso em MINHA função única. não preciso da matriz antiga, quero uma função rápida. então eu usei 2 enquanto loops + emenda.unique4()

Inútil dizer que fiquei impressionado.

chrome: as 150.000 operações usuais por segundo saltaram para 1.800.000 operações por segundo.

ou seja: 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

Prova http://jsperf.com/wgu ou melhor, use console.time ... microtime ... qualquer que seja

unique5() é apenas para mostrar o que acontece se você deseja manter a matriz antiga.

Não use Array.prototypese você não sabe o que está fazendo. Eu apenas fiz um monte de cópia e passado. Use Object.defineProperty(Array.prototype,...,writable:false,enumerable:false})se você deseja criar um protótipo nativo. Exemplo: https://stackoverflow.com/a/20463021/2450730

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

NOTA: sua matriz antiga é destruída / torna-se única após esta operação.

se você não consegue ler o código acima, pergunte, leia um livro javascript ou aqui estão algumas explicações sobre códigos mais curtos. https://stackoverflow.com/a/21353032/2450730

alguns estão usando indexOf ... não ... http://jsperf.com/dgfgghfghfghghgfhgfhfghfhgfh

para matrizes vazias

!array.length||toUnique(array); 

Muitas das respostas aqui podem não ser úteis para iniciantes. Se a remoção de duping de uma matriz for difícil, eles realmente saberão sobre a cadeia de protótipos ou mesmo sobre o jQuery?

Nos navegadores modernos, uma solução limpa e simples é armazenar dados em um conjunto , projetado para ser uma lista de valores exclusivos.

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

O Array.fromé útil para converter parte de trás Set para uma matriz para que você tenha acesso fácil a todos os métodos impressionantes (características) que as matrizes têm. Existem também outras maneiras de fazer a mesma coisa. Mas você pode não precisar Array.from, pois o Sets possui muitos recursos úteis, como o forEach .

Se você precisar dar suporte ao Internet Explorer antigo e, portanto, não puder usar o Set, uma técnica simples é copiar itens para uma nova matriz e verificar com antecedência se eles já estão na nova 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 tornar isso instantaneamente reutilizável, vamos colocá-lo em uma função.

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

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

        return result;
    }
}

Então, para se livrar das duplicatas, faríamos agora isso.

var uniqueCars = deduplicate(cars);

A deduplicate(cars)parte se torna a coisa que chamamos de resultado quando a função é concluída.

Apenas passe o nome de qualquer array que você desejar.

["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 fazer isso 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);

// A saída será

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

Este protótipo getUniquenão está totalmente correto, porque se eu tiver um Array como: ["1",1,2,3,4,1,"foo"]ele retornará ["1","2","3","4"]e "1"é string e 1é um número inteiro; Eles são diferentes.

Aqui está uma solução correta:

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

usando:

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

O acima irá produzir ["1",2,3,4,1,"foo"].

Sem estender Array.prototype (é considerado uma prática ruim) ou usar jquery / underscore, você pode simplesmente filtera matriz.

Mantendo a última ocorrência:

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

ou primeira ocorrência:

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

Bem, é apenas javascript ECMAScript 5+, o que significa apenas IE9 +, mas é bom para o desenvolvimento em HTML / JS nativo (Windows Store App, Firefox OS, Sencha, Phonegap, Titanium, ...).

Magia

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

O (n) desempenho ; assumimos que sua matriz está em ae t={}. Explicação aqui (+ 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 é o mais simples e mencionado no 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 você estiver usando a estrutura Prototype, não há necessidade de fazer loops 'for', você pode usar http://www.prototypejs.org/api/array/uniq assim:

var a = Array.uniq();  

O que produzirá uma matriz duplicada sem duplicatas. Me deparei com sua pergunta procurando um método para contar registros de matriz distintos, para depois

uniq ()

eu usei

Tamanho()

e houve o meu resultado simples. ps Desculpe se eu digitei algo errado

editar: se você quiser escapar de registros indefinidos, poderá adicionar

compactar()

antes, assim:

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

Agora, usando conjuntos, você pode remover duplicatas e convertê-las novamente na matriz.

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

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

Outra solução é usar classificação e 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);

Isso 0ocorre porque é um valor falso no JavaScript.

this[i] será falso se o valor da matriz for 0 ou qualquer outro 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
}

Eu tive um problema um pouco diferente, em que precisei remover objetos com propriedades de identificação duplicadas de uma matriz. isso funcionou.

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

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

console.log(objArr);

A resposta mais simples é:

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

Não sei por que Gabriel Silveira escreveu a função dessa maneira, mas uma forma mais simples que funciona para mim da mesma forma e sem a minificação é:

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

ou no CoffeeScript:

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

Se você concorda com dependências extras ou já possui uma das bibliotecas da sua base de código, pode remover duplicatas de uma matriz no local usando LoDash (ou Sublinhado).

Uso

Se você ainda não o possui na sua base de código, instale-o usando o npm:

npm install lodash

Em seguida, use-o da seguinte maneira:

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

Fora:

[ 1, 2, 3 ]

Isso foi muito respondido, mas não atendeu minha necessidade particular.

Muitas respostas são assim:

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

Mas isso não funciona para matrizes de objetos complexos.

Digamos que temos uma matriz como esta:

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

Se queremos os objetos com nomes exclusivos, devemos usar em array.prototype.findIndexvez de array.prototype.indexOf:

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

De Shamasis Bhattacharya blog do (complexidade O (2n) tempo):

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

No blog de Paul Irish : aprimoramento no 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]

Localizando valores exclusivos de matriz em método simples

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 perdemos a resposta de Rafael , que permaneceu como resposta aceita por alguns anos. Essa foi (pelo menos em 2017) a solução com melhor desempenho se você não tiver uma matriz de 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 você fazer tem uma matriz de tipo misto, você pode serializar a chave de hash:

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 resolver o problema de maneira inversa, pode ser útil não duplicar enquanto você carrega sua matriz, da maneira que o objeto Set faria, mas ainda não está disponível em todos os navegadores. Ele economiza memória e é mais eficiente se você precisar examinar o conteúdo várias vezes.

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

Amostra:

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

Da-te set = [1,3,4,2]