Bagaimana saya bisa mendapatkan daftar nilai unik dalam array? Apakah saya selalu harus menggunakan array kedua atau ada sesuatu yang mirip dengan hashmap java di JavaScript?

Saya akan menggunakan JavaScript dan jQuery saja. Tidak ada perpustakaan tambahan yang dapat digunakan.

Karena saya meneruskannya di komentar untuk jawaban @ Rocket, saya mungkin juga memberikan contoh yang tidak menggunakan perpustakaan. Ini membutuhkan dua fungsi prototipe baru, containsdanunique

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

Untuk keandalan yang lebih, Anda dapat mengganti containsdengan indexOfshim MDN dan memeriksa apakah setiap elemen indexOfsama dengan dokumentasi -1 :.

Atau bagi mereka yang mencari satu-liner (sederhana dan fungsional), kompatibel dengan browser saat ini :

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

Perbarui 18-04-2017

Tampaknya seolah-olah 'Array.prototype.includes' sekarang memiliki dukungan luas di versi terbaru dari browser utama ( kompatibilitas )

Pembaruan 29-07-2015:

Ada rencana dalam karya untuk browser untuk mendukung metode 'Array.prototype.includes' standar, yang meskipun tidak secara langsung menjawab pertanyaan ini; sering terkait.

Pemakaian:

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

Pollyfill ( dukungan browser , sumber dari 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;
    }
  });
}

Inilah solusi yang jauh lebih bersih untuk ES6 yang saya lihat tidak termasuk di sini. Ini menggunakan Set dan operator spread :...

var a = [1, 1, 2];

[... new Set(a)]

Yang kembali [1, 2]

Satu Liner, JavaScript Murni

Dengan sintaks 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")

Dengan sintaks ES5

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

Kompatibilitas Browser : IE9 +

Menggunakan EcmaScript 2016 Anda bisa melakukannya seperti ini.

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

Set selalu unik, dan menggunakan Array.from() Anda dapat mengonversi Set ke array. Untuk referensi, lihat dokumentasi.

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 /Set

Sekarang di ES6 kita dapat menggunakan fungsi ES6 yang baru diperkenalkan

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

ATAU oleh Array menyebar sintaks pada iterables

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

Ini akan mengembalikan hasil yang unik.

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

Jika Anda ingin membiarkan array asli tetap utuh,

Anda memerlukan array kedua untuk memuat elemen unik dari first-

Sebagian besar browser memiliki 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;
    }

Saat ini, Anda dapat menggunakan tipe data Set ES6 untuk mengonversi array Anda ke Set unik. Kemudian, jika Anda perlu menggunakan metode array, Anda dapat mengubahnya kembali menjadi Array:

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"

Bukan asli dalam Javascript, tetapi banyak perpustakaan memiliki metode ini.

_.uniq(array)( Tautan ) Underscore.js bekerja dengan sangat baik ( sumber ).

Menggunakan jQuery, inilah fungsi unik Array yang saya buat:

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]

Solusi pendek dan manis menggunakan array kedua;

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

Cepat, ringkas, tanpa loop bersarang, bekerja dengan objek apa pun, tidak hanya string dan angka, mengambil predikat, dan hanya 5 baris kode !!

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

Contoh: Untuk menemukan barang unik berdasarkan jenis:

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

Jika Anda ingin menemukan item unik pertama, bukan yang terakhir tambahkan found.hasOwnPropery () periksa di sana.

Anda hanya perlu vanilla JS untuk menemukan unik dengan Array.some dan Array.reduce. Dengan sintaksis ES2015 hanya 62 karakter.

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

Array.some dan Array.reduce didukung di IE9 + dan browser lainnya. Cukup ubah fungsi panah gemuk untuk mendukung fungsi biasa di browser yang tidak mendukung sintaks 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 / Kurangi

Sebagian besar solusi di atas memiliki kompleksitas waktu lari yang tinggi.

Berikut adalah solusi yang menggunakan reducedan dapat melakukan pekerjaan dalam waktu O (n).

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

catatan:

Solusi ini tidak bergantung pada pengurangan. Idenya adalah untuk membuat peta objek dan mendorong yang unik ke dalam array.

Cara ES6:

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

kamu bisa memakai,

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

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

itu akan memberi Anda elemen unik,

**> tapi ada tangkapan,

untuk "1" dan 1 ini dan merupakan elemen berbeda, **

Opsi kedua adalah menggunakan metode filter pada array.

Anda dapat memasukkan array dengan duplikat dan metode di bawah ini akan mengembalikan array dengan elemen unik.

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

Satu-satunya masalah dengan solusi yang diberikan sejauh ini adalah efisiensi. Jika Anda khawatir tentang itu (dan Anda mungkin harus), Anda perlu menghindari loop bersarang: untuk * untuk, filter * indexOf, grep * inArray, semuanya mengulangi array beberapa kali. Anda dapat menerapkan satu loop dengan solusi seperti ini atau ini

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

Saya telah mencoba masalah ini di JS murni. Saya telah mengikuti langkah-langkah berikut: 1. Urutkan array yang diberikan, 2. loop melalui array yang diurutkan, 3. Verifikasi nilai sebelumnya dan nilai berikutnya dengan nilai saat ini

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

Mengingat yang indexOfakan mengembalikan kemunculan pertama elemen, Anda dapat melakukan sesuatu seperti ini:

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

Jika Anda tidak perlu terlalu khawatir tentang browser lama, inilah yang dirancang untuk Sets.

Objek Set memungkinkan Anda menyimpan nilai unik dari jenis apa pun, baik nilai primitif atau referensi objek.

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}

Pemikiran lain dari pertanyaan ini. Inilah yang saya lakukan untuk mencapai ini dengan kode lebih sedikit.

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

Berikut ini adalah pendekatan dengan equalsfungsi yang dapat dikustomisasi yang dapat digunakan untuk primitif maupun untuk objek kustom:

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
}

pemakaian:

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

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

Jawaban saya menggunakan Array.filterdan Array.indexOfmetode untuk mendapatkan nilai unik

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

Saya melihat pendekatan ini di sebuah situs web tetapi kode mereka berbeda dari yang terlihat di sini. Saya telah menyederhanakan kode menjadi satu baris dan mempostingnya di sini sehingga seseorang akan mendapat manfaat darinya

Catatan: Pendekatan saya mirip atau sama dengan liner yang diposting oleh Josh. Saya meninggalkannya di sini karena nama variabel cukup jelas dalam kode saya.

Saya hanya berpikir jika kita dapat menggunakan pencarian linear untuk menghilangkan duplikat:

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>

Berikut adalah solusi satu liner untuk masalah ini:

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

Salin tempel ini ke konsol browser dan dapatkan hasilnya, ya :-)

saya punya fungsi unik JQuery inbuilt .

uniqueValues= jQuery.unique( duplicateValues );

Untuk lebih lanjut Anda bisa merujuk ke Dokumentasi API jquery.

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