¿Cómo puedo obtener una lista de valores únicos en una matriz? ¿Siempre tengo que usar una segunda matriz o hay algo similar al hashmap de java en JavaScript?

Voy a usar JavaScript y jQuery solamente. No se pueden usar bibliotecas adicionales.

Como lo mencioné en los comentarios para la respuesta de @ Rocket, también puedo proporcionar un ejemplo que no use bibliotecas. Esto requiere dos nuevas funciones prototipo, containsyunique

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 mayor confiabilidad, puede reemplazar containscon la indexOfcuña de MDN y verificar si cada elemento indexOfes igual a -1: documentación

O para aquellos que buscan un one-liner (simple y funcional), compatible con los navegadores actuales :

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

Actualización 18-04-2017

Parece que 'Array.prototype.includes' ahora tiene un amplio soporte en las últimas versiones de los navegadores principales ( compatibilidad )

Actualización 29-07-2015:

Hay planes en proceso para que los navegadores admitan un método estandarizado 'Array.prototype.includes', que aunque no responde directamente a esta pregunta; A menudo está relacionado.

Uso:

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

Pollyfill ( soporte de navegador , fuente de 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;
    }
  });
}

Aquí hay una solución mucho más limpia para ES6 que veo que no está incluida aquí. Utiliza el conjunto y el operador de propagación :...

var a = [1, 1, 2];

[... new Set(a)]

Que vuelve [1, 2]

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 +

Usando EcmaScript 2016 simplemente puede hacerlo así.

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

Los conjuntos son siempre únicos y, al usarlos Array.from(), puede convertir un conjunto en una matriz. Como referencia, eche un vistazo a las documentaciones.

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

Ahora en ES6 podemos usar la función ES6 recientemente introducida

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

O por la sintaxis de propagación de matriz en iterables

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

Devolverá el resultado único.

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

Si desea dejar la matriz original intacta,

necesita una segunda matriz para contener los elementos únicos de la primera

La mayoría de los navegadores tienen 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;
    }

En estos días, puede usar el tipo de datos Set de ES6 para convertir su matriz en un Set único. Luego, si necesita usar métodos de matriz, puede convertirlo nuevamente en una 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"

No es nativo en Javascript, pero muchas bibliotecas tienen este método.

Underscore.js's _.uniq(array)( enlace ) funciona bastante bien ( fuente ).

Usando jQuery, aquí hay una función única de Array que hice:

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]

Solución corta y dulce usando una 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, sin bucles anidados, funciona con cualquier objeto, no solo cadenas y números, toma un predicado y solo 5 líneas de código!

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

Ejemplo: para buscar elementos únicos 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'}
//  ] 

Si desea que encuentre el primer elemento único en lugar del último, agregue una marca found.hasOwnPropery () allí.

Solo necesita Vanilla JS para encontrar elementos únicos con Array.some y Array.reduce. Con la sintaxis ES2015, solo tiene 62 caracteres.

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

Array.some y Array.reduce son compatibles con IE9 + y otros navegadores. Simplemente cambie las funciones de flecha gruesa para que las funciones regulares se admitan en navegadores que no admiten la sintaxis 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 / Array / Reducir

La mayoría de las soluciones anteriores tienen una alta complejidad de tiempo de ejecución.

Aquí está la solución que usa reducey puede hacer el trabajo en O (n) tiempo.

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 solución no depende de reducir. La idea es crear un mapa de objetos e insertar unos únicos en la matriz.

Manera ES6:

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

puedes usar,

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

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

te dará elementos únicos,

**> pero hay una trampa,

para este "1" y 1 y son elementos diff, **

La segunda opción es utilizar el método de filtro en la matriz.

Puede ingresar una matriz con duplicados y el método siguiente devolverá la matriz con elementos únicos.

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

El único problema con las soluciones dadas hasta ahora es la eficiencia. Si le preocupa eso (y probablemente debería), debe evitar los bucles anidados: for * for, filter * indexOf, grep * inArray, todos iteran la matriz varias veces. Puede implementar un solo ciclo con soluciones como esta o 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; 
}

He intentado este problema en JS puro. He seguido los siguientes pasos 1. Ordene la matriz dada, 2. recorra la matriz ordenada, 3. Verifique el valor anterior y el valor siguiente con el valor actual

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

Manifestación

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

Teniendo en cuenta que indexOfdevolverá la primera aparición de un elemento, puede hacer algo como esto:

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

Si no necesita preocuparse tanto por los navegadores antiguos, esto es exactamente para lo que están diseñados los Conjuntos.

El objeto Set le permite almacenar valores únicos de cualquier tipo, ya sean valores primitivos o referencias de 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}

Otro pensamiento de esta pregunta. Esto es lo que hice para lograr esto con 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);

Aquí hay un enfoque con una equalsfunción personalizable que puede usarse para primitivas y también 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)

Mi respuesta utiliza Array.filtery Array.indexOfmétodos para obtener los valores únicos

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

Vi este enfoque en un sitio web pero su código es diferente de lo que parece aquí. He simplificado el código a una línea y lo he publicado aquí para que alguien se beneficie de él.

Nota: Mi enfoque es similar o igual al del trazador de líneas publicado por Josh. Lo dejo aquí ya que los nombres de las variables se explican por sí mismos en mi código.

Estaba pensando si podemos usar la búsqueda lineal para eliminar los duplicados:

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>

Aquí está la solución única al problema:

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

Copie y pegue esto en la consola del navegador y obtenga los resultados, yo :-)

He incorporado la función JQuery Unique .

uniqueValues= jQuery.unique( duplicateValues );

Para obtener más información, puede consultar las Documentaciones de la API de jquery.

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