Làm thế nào tôi có thể nhận được một danh sách các giá trị duy nhất trong một mảng? Tôi có luôn phải sử dụng mảng thứ hai hay có thứ gì đó tương tự như hashmap của java trong JavaScript không?

Tôi sẽ chỉ sử dụng JavaScript và jQuery . Không có thư viện bổ sung có thể được sử dụng.

Vì tôi đã tiếp tục về nó trong các bình luận cho câu trả lời của @ Rocket, tôi cũng có thể cung cấp một ví dụ không sử dụng thư viện. Điều này đòi hỏi hai chức năng nguyên mẫu mới containsvàunique

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

Để có độ tin cậy cao hơn, bạn có thể thay thế containsbằng indexOfshim của MDN và kiểm tra xem mỗi phần tử indexOfcó bằng -1: tài liệu không

Hoặc đối với những người tìm kiếm một lớp lót (đơn giản và chức năng), tương thích với các trình duyệt hiện tại :

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

Cập nhật 18-04-2017

Nó xuất hiện như thể 'Array.prototype.includes' hiện có hỗ trợ rộng rãi trong các phiên bản mới nhất của trình duyệt chính ( tương thích )

Cập nhật 29-07-2015:

Có các kế hoạch trong công việc để các trình duyệt hỗ trợ phương thức 'Array.prototype.includes' được tiêu chuẩn hóa, mặc dù không trả lời trực tiếp câu hỏi này; thường liên quan.

Sử dụng:

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

Pollyfill ( hỗ trợ trình duyệt , nguồn từ 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;
    }
  });
}

Đây là một giải pháp sạch hơn cho ES6 mà tôi thấy không bao gồm ở đây. Nó sử dụng toán tử Set và toán tử trải rộng :...

var a = [1, 1, 2];

[... new Set(a)]

Trả về [1, 2]

Một lớp lót, JavaScript thuần

Với cú pháp 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")

Với cú pháp ES5

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

Khả năng tương thích trình duyệt : IE9 +

Bây giờ trong ES6 chúng ta có thể sử dụng chức năng ES6 mới được giới thiệu

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

Cú pháp trải rộng OR by Array trên iterables

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

Nó sẽ trả về kết quả duy nhất.

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

Sử dụng EcmaScript 2016 bạn chỉ cần làm như thế này.

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

Các bộ luôn là duy nhất và bằng cách sử dụng, Array.from()bạn có thể chuyển đổi Tập hợp thành một mảng. Để tham khảo có một cái nhìn vào các tài liệu.

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_Oject /Bộ

Nếu bạn muốn giữ nguyên mảng ban đầu,

bạn cần một mảng thứ hai để chứa các phần tử uniqe của phần thứ nhất-

Hầu hết các trình duyệt có 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;
    }

Ngày nay, bạn có thể sử dụng loại dữ liệu Set của ES6 để chuyển đổi mảng của bạn thành một Set duy nhất. Sau đó, nếu bạn cần sử dụng các phương thức mảng, bạn có thể biến nó trở lại thành một mảng:

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"

Không có nguồn gốc từ Javascript, nhưng rất nhiều thư viện có phương pháp này.

Underscore.js _.uniq(array)( link ) hoạt động khá tốt ( nguồn ).

Sử dụng jQuery, đây là một hàm duy nhất Array tôi đã tạo:

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]

Giải pháp ngắn và ngọt bằng cách sử dụng mảng thứ hai;

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

Nhanh, gọn, không có vòng lặp lồng nhau, hoạt động với bất kỳ đối tượng nào, không chỉ chuỗi và số, có một vị ngữ và chỉ có 5 dòng mã !!

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

Ví dụ: Để tìm các mục duy nhất theo loại:

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

Nếu bạn muốn nó tìm thấy vật phẩm độc đáo đầu tiên thay vì cuối cùng hãy tìm thấy.hasOwnPropery () hãy đăng ký tại đó.

Bạn chỉ cần vanilla JS để tìm các đơn vị với Array.some và Array.reduce. Với cú pháp ES2015, nó chỉ có 62 ký tự.

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

Array.some và Array.reduce được hỗ trợ trong IE9 + và các trình duyệt khác. Chỉ cần thay đổi các hàm mũi tên béo cho các chức năng thông thường để hỗ trợ trong các trình duyệt không hỗ trợ cú pháp 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_Oject / Mảng / Giảm

Phần lớn các giải pháp trên có độ phức tạp thời gian chạy cao.

Đây là giải pháp sử dụng reducevà có thể thực hiện công việc trong thời gian 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];

Ghi chú:

Giải pháp này không phụ thuộc vào giảm. Ý tưởng là tạo ra một bản đồ đối tượng và đẩy những cái duy nhất vào mảng.

Cách ES6:

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

bạn có thể dùng,

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

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

nó sẽ cung cấp cho bạn các yếu tố độc đáo,

**> nhưng có một nhược điểm,

cho "1" và 1 này và là các phần tử khác, **

Tùy chọn thứ hai là sử dụng phương thức lọc trên mảng.

Bạn có thể nhập mảng với các mục trùng lặp và phương thức bên dưới sẽ trả về mảng với các phần tử duy nhất.

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

Vấn đề duy nhất với các giải pháp được đưa ra cho đến nay là hiệu quả. Nếu bạn lo lắng về điều đó (và có lẽ bạn nên), bạn cần tránh các vòng lặp lồng nhau: for * for, filter * indexOf, grep * inArray, tất cả đều lặp lại mảng nhiều lần. Bạn có thể thực hiện một vòng lặp duy nhất với các giải pháp như thế này hoặc thế này

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

Tôi đã thử vấn đề này trong JS thuần túy. Tôi đã làm theo các bước sau 1. Sắp xếp mảng đã cho, 2. lặp qua mảng đã sắp xếp, 3. Xác minh giá trị trước và giá trị tiếp theo với giá trị hiện tại

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

Bản giới thiệu

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

Trong tâm trí indexOfsẽ trả lại sự xuất hiện đầu tiên của một yếu tố, bạn có thể làm một cái gì đó như thế này:

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

Nếu bạn không cần phải lo lắng quá nhiều về các trình duyệt cũ hơn, thì đây chính xác là những gì Bộ được thiết kế cho.

Đối tượng Set cho phép bạn lưu trữ các giá trị duy nhất thuộc bất kỳ loại nào, cho dù giá trị nguyên thủy hoặc tham chiếu đối tượng.

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}

Một suy nghĩ khác của câu hỏi này. Đây là những gì tôi đã làm để đạt được điều này với ít mã hơn.

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

Đây là một cách tiếp cận với equalschức năng tùy biến có thể được sử dụng cho người nguyên thủy cũng như cho các đối tượng tùy chỉnh:

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
}

sử dụng:

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

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

Câu trả lời của tôi sử dụng Array.filtervà Array.indexOfphương pháp để có được các giá trị duy nhất

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

Tôi thấy cách tiếp cận này trong một trang web nhưng mã của họ khác với ở đây. Tôi đã đơn giản hóa mã thành một dòng và đăng nó ở đây để ai đó sẽ được hưởng lợi từ nó

Lưu ý: Cách tiếp cận của tôi tương tự hoặc giống như một bài đăng của Josh. Tôi để nó ở đây vì các tên biến là tự giải thích trong mã của tôi.

Tôi chỉ nghĩ nếu chúng ta có thể sử dụng tìm kiếm tuyến tính để loại bỏ các bản sao:

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>

Đây là một giải pháp lót cho vấn đề:

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

Sao chép dán này vào bảng điều khiển trình duyệt và nhận kết quả, yo :-)

tôi có sẵn chức năng JQuery Unique .

uniqueValues= jQuery.unique( duplicateValues );

Để biết thêm, bạn có thể tham khảo Tài liệu API jquery.

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