Como posso obter uma lista de valores exclusivos em uma matriz? Eu sempre tenho que usar uma segunda matriz ou há algo semelhante ao hashmap de java em JavaScript?

Vou usar apenas JavaScript e jQuery . Nenhuma biblioteca adicional pode ser usada.

Desde que eu falei sobre isso nos comentários da resposta do @ Rocket, também posso fornecer um exemplo que não usa bibliotecas. Isso requer duas novas funções de protótipo containseunique

Array.prototype.contains = function(v) {
  for (var i = 0; i < this.length; i++) {
    if (this[i] === v) return true;
  }
  return false;
};

Array.prototype.unique = function() {
  var arr = [];
  for (var i = 0; i < this.length; i++) {
    if (!arr.contains(this[i])) {
      arr.push(this[i]);
    }
  }
  return arr;
}

var duplicates = [1, 3, 4, 2, 1, 2, 3, 8];
var uniques = duplicates.unique(); // result = [1,3,4,2,8]

console.log(uniques);

Para obter mais confiabilidade, você pode substituir containspelo indexOfcalço do MDN e verificar se cada elemento indexOfé igual a -1: documentation

Ou para quem procura uma linha (simples e funcional), compatível com os navegadores atuais :

let a = ["1", "1", "2", "3", "3", "1"];
let unique = a.filter((item, i, ar) => ar.indexOf(item) === i);
console.log(unique);

Atualização 18-04-2017

Parece que 'Array.prototype.includes' agora tem amplo suporte nas versões mais recentes dos navegadores principais ( compatibilidade )

Atualização 29-07-2015:

Existem planos em andamento para os navegadores oferecerem suporte a um método padronizado 'Array.prototype.includes', que, embora não responda diretamente a essa pergunta; é frequentemente relacionado.

Uso:

["1", "1", "2", "3", "3", "1"].includes("2");     // true

Pollyfill ( suporte ao navegador , fonte do mozilla ):

// https://tc39.github.io/ecma262/#sec-array.prototype.includes
if (!Array.prototype.includes) {
  Object.defineProperty(Array.prototype, 'includes', {
    value: function(searchElement, fromIndex) {

      // 1. Let O be ? ToObject(this value).
      if (this == null) {
        throw new TypeError('"this" is null or not defined');
      }

      var o = Object(this);

      // 2. Let len be ? ToLength(? Get(O, "length")).
      var len = o.length >>> 0;

      // 3. If len is 0, return false.
      if (len === 0) {
        return false;
      }

      // 4. Let n be ? ToInteger(fromIndex).
      //    (If fromIndex is undefined, this step produces the value 0.)
      var n = fromIndex | 0;

      // 5. If n ≥ 0, then
      //  a. Let k be n.
      // 6. Else n < 0,
      //  a. Let k be len + n.
      //  b. If k < 0, let k be 0.
      var k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);

      // 7. Repeat, while k < len
      while (k < len) {
        // a. Let elementK be the result of ? Get(O, ! ToString(k)).
        // b. If SameValueZero(searchElement, elementK) is true, return true.
        // c. Increase k by 1.
        // NOTE: === provides the correct "SameValueZero" comparison needed here.
        if (o[k] === searchElement) {
          return true;
        }
        k++;
      }

      // 8. Return false
      return false;
    }
  });
}

Aqui está uma solução muito mais limpa para o ES6 que eu vejo que não está incluída aqui. Ele usa o conjunto e o operador de propagação :...

var a = [1, 1, 2];

[... new Set(a)]

Que retorna [1, 2]

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 +

Usando o EcmaScript 2016, você pode simplesmente fazer assim.

 var arr = ["a", "a", "b"];
 var uniqueArray = Array.from(new Set(arr)); // Unique Array ['a', 'b'];

Os conjuntos são sempre exclusivos e, com Array.from()o uso, você pode converter um conjunto em uma matriz. Para referência, dê uma olhada nas documentações.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects /Conjunto

Agora no ES6, podemos usar a recém-introduzida função ES6

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

OR by Array espalhar sintaxe em iterables

let items = [1,1,1,1,3,4,5,2,23,1,4,4,4,2,2,2]; 
let uniqueItems = [...new Set(items)];

Retornará o resultado exclusivo.

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

Se você quiser deixar a matriz original intacta,

você precisa de uma segunda matriz para conter os elementos uniqe do primeiro

A maioria dos navegadores possui Array.prototype.filter:

var unique= array1.filter(function(itm, i){
    return array1.indexOf(itm)== i; 
    // returns true for only the first instance of itm
});


//if you need a 'shim':
Array.prototype.filter= Array.prototype.filter || function(fun, scope){
    var T= this, A= [], i= 0, itm, L= T.length;
    if(typeof fun== 'function'){
        while(i<L){
            if(i in T){
                itm= T[i];
                if(fun.call(scope, itm, i, T)) A[A.length]= itm;
            }
            ++i;
        }
    }
    return A;
}
 Array.prototype.indexOf= Array.prototype.indexOf || function(what, i){
        if(!i || typeof i!= 'number') i= 0;
        var L= this.length;
        while(i<L){
            if(this[i]=== what) return i;
            ++i;
        }
        return -1;
    }

Hoje em dia, você pode usar o tipo de dados Set do ES6 para converter sua matriz em um conjunto exclusivo. Então, se você precisar usar métodos de matriz, poderá transformá-lo novamente em uma matriz:

var arr = ["a", "a", "b"];
var uniqueSet = new Set(arr); // {"a", "b"}
var uniqueArr = Array.from(uniqueSet); // ["a", "b"]
//Then continue to use array methods:
uniqueArr.join(", "); // "a, b"

Não é nativo em Javascript, mas muitas bibliotecas têm esse método.

Das Underscore.js _.uniq(array)( ligação ) funciona muito bem ( fonte ).

Usando jQuery, aqui está uma função exclusiva de matriz que eu criei:

Array.prototype.unique = function () {
    var arr = this;
    return $.grep(arr, function (v, i) {
        return $.inArray(v, arr) === i;
    });
}

console.log([1,2,3,1,2,3].unique()); // [1,2,3]

Solução curta e doce usando segunda matriz;

var axes2=[1,4,5,2,3,1,2,3,4,5,1,3,4];

    var distinct_axes2=[];

    for(var i=0;i<axes2.length;i++)
        {
        var str=axes2[i];
        if(distinct_axes2.indexOf(str)==-1)
            {
            distinct_axes2.push(str);
            }
        }
    console.log("distinct_axes2 : "+distinct_axes2); // distinct_axes2 : 1,4,5,2,3

Rápido, compacto, sem loops aninhados, funciona com qualquer objeto, não apenas com strings e números, assume um predicado e apenas 5 linhas de código !!

function findUnique(arr, predicate) {
  var found = {};
  arr.forEach(d => {
    found[predicate(d)] = d;
  });
  return Object.keys(found).map(key => found[key]); 
}

Exemplo: para encontrar itens exclusivos por tipo:

var things = [
  { name: 'charm', type: 'quark'},
  { name: 'strange', type: 'quark'},
  { name: 'proton', type: 'boson'},
];

var result = findUnique(things, d => d.type);
//  [
//    { name: 'charm', type: 'quark'},
//    { name: 'proton', type: 'boson'}
//  ] 

Se você deseja que ele encontre o primeiro item exclusivo em vez do último, adicione um check found.hasOwnPropery () lá.

Você só precisa do vanilla JS para encontrar itens únicos com Array.some e Array.reduce. Com a sintaxe do ES2015, são apenas 62 caracteres.

a.reduce((c, v) => b.some(w => w === v) ? c : c.concat(v)), b)

Array.some e Array.reduce são suportados no IE9 + e em outros navegadores. Basta alterar as funções de seta gorda para obter funções regulares para suporte em navegadores que não suportam a sintaxe do ES2015.

var a = [1,2,3];
var b = [4,5,6];
// .reduce can return a subset or superset
var uniques = a.reduce(function(c, v){
    // .some stops on the first time the function returns true                
    return (b.some(function(w){ return w === v; }) ?  
      // if there's a match, return the array "c"
      c :     
      // if there's no match, then add to the end and return the entire array                                        
      c.concat(v)}),                                  
  // the second param in .reduce is the starting variable. This is will be "c" the first time it runs.
  b);                                                 

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects / Matriz / Reduzir

A maioria das soluções acima tem uma alta complexidade de tempo de execução.

Aqui está a solução que usa reducee pode fazer o trabalho em O (n) tempo.

Array.prototype.unique = Array.prototype.unique || function() {
        var arr = [];
	this.reduce(function (hash, num) {
		if(typeof hash[num] === 'undefined') {
			hash[num] = 1; 
			arr.push(num);
		}
		return hash;
	}, {});
	return arr;
}
    
var myArr = [3,1,2,3,3,3];
console.log(myArr.unique()); //[3,1,2];

Nota:

Esta solução não depende de redução. A idéia é criar um mapa de objetos e inserir mapas exclusivos na matriz.

ES6 maneira:

const uniq = (arr) => (arr.filter((item, index, arry) => (arry.indexOf(item) === index)));

você pode usar,

let arr1 = [1,2,1,3];
let arr2 = [2,3,4,5,1,2,3];

let arr3 = [...new Set([...arr1,...arr2])];

isso lhe dará elementos únicos,

**> mas há um problema,

para este "1" e 1 e são elementos diff, **

A segunda opção é usar o método de filtro na matriz.

Você pode inserir a matriz com duplicatas e o método abaixo retornará a matriz com elementos exclusivos.

function getUniqueArray(array){
    var uniqueArray = [];
    if (array.length > 0) {
       uniqueArray[0] = array[0];
    }
    for(var i = 0; i < array.length; i++){
        var isExist = false;
        for(var j = 0; j < uniqueArray.length; j++){
            if(array[i] == uniqueArray[j]){
                isExist = true;
                break;
            }
            else{
                isExist = false;
            }
        }
        if(isExist == false){
            uniqueArray[uniqueArray.length] = array[i];
        }
    }
    return uniqueArray;
}

O único problema com as soluções dadas até agora é a eficiência. Se você está preocupado com isso (e provavelmente deveria), precisa evitar loops aninhados: para * for, filter * indexOf, grep * inArray, todos iteram a matriz várias vezes. Você pode implementar um único loop com soluções como esta ou esta

Array.prototype.unique = function () {
    var dictionary = {};
    var uniqueValues = [];
    for (var i = 0; i < this.length; i++) {
        if (dictionary[this[i]] == undefined){
            dictionary[this[i]] = i;
            uniqueValues.push(this[i]);
        }
    }
    return uniqueValues; 
}

Eu tentei esse problema em JS puro. Eu segui as etapas a seguir 1. Classifique a matriz fornecida, 2. faça um loop na matriz classificada, 3. Verifique o valor anterior e o próximo valor com o valor atual

// JS
var inpArr = [1, 5, 5, 4, 3, 3, 2, 2, 2,2, 100, 100, -1];

//sort the given array
inpArr.sort(function(a, b){
    return a-b;
});

var finalArr = [];
//loop through the inpArr
for(var i=0; i<inpArr.length; i++){
    //check previous and next value 
  if(inpArr[i-1]!=inpArr[i] && inpArr[i] != inpArr[i+1]){
        finalArr.push(inpArr[i]);
  }
}
console.log(finalArr);

Demo

function findUniques(arr){
  let uniques = []
  arr.forEach(n => {
    if(!uniques.includes(n)){
      uniques.push(n)
    }       
  })
  return uniques
}

let arr = ["3", "3", "4", "4", "4", "5", "7", "9", "b", "d", "e", "f", "h", "q", "r", "t", "t"]

findUniques(arr)
// ["3", "4", "5", "7", "9", "b", "d", "e", "f", "h", "q", "r", "t"]

Tendo em mente que indexOfretornará a primeira ocorrência de um elemento, você pode fazer algo assim:

Array.prototype.unique = function(){
        var self = this;
        return this.filter(function(elem, index){
            return self.indexOf(elem) === index;
        })
    }

Se você não precisa se preocupar tanto com navegadores antigos, é exatamente para isso que os Sets são projetados.

O objeto Set permite armazenar valores exclusivos de qualquer tipo, sejam valores primitivos ou referências a objetos.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set

const set1 = new Set([1, 2, 3, 4, 5, 1]);
// returns Set(5) {1, 2, 3, 4, 5}

Outro pensamento sobre esta questão. Aqui está o que eu fiz para conseguir isso com menos código.

var distinctMap = {};
var testArray = ['John', 'John', 'Jason', 'Jason'];
for (var i = 0; i < testArray.length; i++) {
  var value = testArray[i];
  distinctMap[value] = '';
};
var unique_values = Object.keys(distinctMap);

console.log(unique_values);

Aqui está uma abordagem com equalsfunção personalizável que pode ser usada para primitivos e também para objetos personalizados:

Array.prototype.pushUnique = function(element, equalsPredicate = (l, r) => l == r) {
    let res = !this.find(item => equalsPredicate(item, element))
    if(res){
        this.push(element)
    }
    return res
}

uso:

//with custom equals for objects
myArrayWithObjects.pushUnique(myObject, (left, right) => left.id == right.id)

//with default equals for primitives
myArrayWithPrimitives.pushUnique(somePrimitive)

Minha resposta usa Array.filtere Array.indexOfmétodos para obter valores únicos

array.filter((value, index, self)=>self.indexOf(value)===index)

Eu vi essa abordagem em um site, mas o código deles é diferente do que parece aqui. Simplifiquei o código para uma linha e publiquei aqui para que alguém se beneficie dele

Nota: Minha abordagem é semelhante ou igual à liner postada por Josh. Estou deixando aqui, pois os nomes das variáveis ​​são auto-explicativos no meu código.

Eu só estava pensando se podemos usar a pesquisa linear para eliminar as duplicatas:

JavaScript:
function getUniqueRadios() {

var x=document.getElementById("QnA");
var ansArray = new Array();
var prev;


for (var i=0;i<x.length;i++)
  {
    // Check for unique radio button group
    if (x.elements[i].type == "radio")
    {
            // For the first element prev will be null, hence push it into array and set the prev var.
            if (prev == null)
            {
                prev = x.elements[i].name;
                ansArray.push(x.elements[i].name);
            } else {
                   // We will only push the next radio element if its not identical to previous.
                   if (prev != x.elements[i].name)
                   {
                       prev = x.elements[i].name;
                       ansArray.push(x.elements[i].name);
                   }
            }
    }

  }

   alert(ansArray);

}

HTML:

<body>

<form name="QnA" action="" method='post' ">

<input type="radio"  name="g1" value="ANSTYPE1"> good </input>
<input type="radio" name="g1" value="ANSTYPE2"> avg </input>

<input type="radio"  name="g2" value="ANSTYPE3"> Type1 </input>
<input type="radio" name="g2" value="ANSTYPE2"> Type2 </input>


<input type="submit" value='SUBMIT' onClick="javascript:getUniqueRadios()"></input>


</form>
</body>

Aqui está a solução única para o problema:

var seriesValues = [120, 120, 120, 120];
seriesValues = seriesValues.filter((value, index, seriesValues) => (seriesValues.slice(0, index)).indexOf(value) === -1);
console.log(seriesValues);

Copie e cole isso no console do navegador e obtenha os resultados, yo :-)

Eu tenho a função JQuery Unique embutida.

uniqueValues= jQuery.unique( duplicateValues );

Para mais, consulte a documentação da API do jquery.

http://api.jquery.com/jquery.unique/