고유 해야하는 숫자 배열이 있습니다. 인터넷에서 아래 코드 스 니펫을 발견했으며 배열에 0이 될 때까지 훌륭하게 작동합니다. Stack Overflow에서 거의 다른 것처럼 보이는 다른 스크립트를 찾았 지만 실패하지는 않습니다.

그래서 내가 배우는 것을 돕기 위해 누군가가 프로토 타입 스크립트가 잘못되는 것을 결정하도록 도울 수 있습니까?

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

중복 질문에서 더 많은 답변 :

• JS 배열에서 중복 값 제거

비슷한 질문 :

• 배열에서 고유하지 않은 모든 값 (예 : 중복 / 둘 이상의 발생)을 가져옵니다.

와 자바 스크립트 1.6 / 인 ECMAScript 5 당신은 기본 사용할 수있는 filter고유 한 값으로 배열을 얻기 위해 다음과 같은 방법으로 배열의 방법 :

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

네이티브 메소드 filter는 배열을 반복하여 주어진 콜백 함수를 전달하는 항목 만 남겨 둡니다 onlyUnique.

onlyUnique주어진 값이 처음 발생하는지 확인합니다. 그렇지 않은 경우 복제본이어야하며 복사되지 않습니다.

이 솔루션은 jQuery 또는 prototype.js와 같은 추가 라이브러리없이 작동합니다.

혼합 값 유형을 가진 배열에서도 작동합니다.

오래된 브라우저 (<IE9), 즉, 네이티브 메소드를 지원하지 않습니다 filter그리고 indexOf당신을위한 MDN 문서의 작업 방법을 찾을 수 있습니다 필터 와 같이 IndexOf .

마지막으로 나타나는 값을 유지하려면 다음과 같이 간단히 바꾸십시오 indexOf.lastIndexOf .

ES6을 사용하면 다음과 같이 단축 될 수 있습니다.

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

Camilo Martin 에게 감사합니다의견에 힌트를 에게 .

ES6에는 Set고유 한 값을 저장 하는 기본 개체 가 있습니다. 고유 한 값을 가진 배열을 얻으려면 다음과 같이하십시오 :

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

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

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

의 생성자는 SetArray와 같은 반복 가능한 객체 를 가져오고 스프레드 연산자 ...는 집합을 다시 Array로 변환합니다. 의견에 힌트를 준 Lukas Liese 에게 감사드립니다 .

ES6 / ES2015에 대한 업데이트 된 답변 : Set 사용 하면 단일 라인 솔루션은 다음과 같습니다.

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

어떤 반환

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

마찬가지로 le_m이 제안이 또한 사용을 단축 할 수 확산 연산자 처럼

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

나는이 질문에 이미 30 개 이상의 답변이 있음을 알고 있습니다. 그러나 나는 기존의 모든 대답을 먼저 읽고 내 자신의 연구를했습니다.

나는 모든 대답을 4 가지 가능한 해결책으로 나눕니다.

1. 새로운 ES6 기능을 사용하십시오. [...new Set( [1, 1, 2] )];
2. { }중복을 방지하기 위해 객체 를 사용
3. 헬퍼 배열 사용 [ ]
4. 사용하다 filter + indexOf

답변에서 찾은 샘플 코드는 다음과 같습니다.

새로운 ES6 기능을 사용하십시오. [...new Set( [1, 1, 2] )];

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

{ }중복을 방지하기 위해 객체 를 사용

function uniqueArray1( ar ) {
  var j = {};

  ar.forEach( function(v) {
    j[v+ '::' + typeof v] = v;
  });

  return Object.keys(j).map(function(v){
    return j[v];
  });
} 

헬퍼 배열 사용 [ ]

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

사용하다 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;
}

그리고 어느 것이 더 빠른지 궁금했습니다. 샘플 Google 스프레드 시트를 만들었습니다.기능을 테스트하기 위해 를 . 참고 : ECMA 6은 Google 스프레드 시트에서 사용할 수 없으므로 테스트 할 수 없습니다.

테스트 결과는 다음과 같습니다.

{ }해시를 사용하기 때문에 객체 를 사용하는 코드 가 승리 할 것으로 예상 했습니다. 테스트 결과 Chrome 및 IE에서이 알고리즘에 대한 최상의 결과를 보여주었습니다. 코드를 위한 @rab에 감사합니다 .

underscore.js를 사용할 수도 있습니다 .

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

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

다음을 반환합니다 :

[1, 2, 3, 4]

하나의 라이너, 순수한 JavaScript

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

ES5 구문 사용

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

브라우저 호환성 : IE9 +

jQuery를 사용하는 멋진 메소드를 찾았습니다.

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

참고 :이 코드는 Paul Irish의 오리 펀치 포스트 에서 가져 왔습니다 .

ES6를 사용한 최단 솔루션 : [...new Set( [1, 1, 2] )];

또는 원래 질문에서와 같이 Array 프로토 타입을 수정하려는 경우 :

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

EcmaScript 6은 현재 최신 브라우저 (2015 년 8 월) 에서만 일부만 구현 되지만 Babel 은 ES6 (및 ES7)을 ES5로 다시 컴파일하는 데 매우 유명해졌습니다. 그렇게하면 오늘 ES6 코드를 작성할 수 있습니다!

...의미 가 궁금하다면 스프레드 연산자 라고합니다 . From MDN :«확산 연산자를 사용하면 여러 인수 (함수 호출) 또는 여러 요소 (배열 리터럴)가 필요한 위치에서 식을 확장 할 수 있습니다». Set은 반복 가능하고 고유 한 값만 가질 수 있으므로 스프레드 연산자는 Set을 확장하여 배열을 채 웁니다.

ES6 학습을위한 자료 :

• Axel Rauschmayer 박사의 ES6 탐색
• JS 주간 뉴스 레터에서 "ES6"검색
• Mozilla Hacks 블로그의 심층 기사 ES6

가장 간단한 해결책 :

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

또는:

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

이 작업을 수행하는 가장 간단하고 빠른 방법 (Chrome) :

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

단순히 배열의 모든 항목을 살펴보고 해당 항목이 이미 목록에 있는지 테스트하고 그렇지 않은 경우 반환되는 배열로 푸시합니다.

jsPerf에 따르면이 기능은 어디에서나 찾을 수있는 기능 중 가장 빠릅니다 .

비 프로토 타입 버전 :

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

정렬

배열을 정렬해야 할 때 다음이 가장 빠릅니다.

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

또는 비 프로토 타입 :

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

이것은 또한 빠른 위의 방법보다 대부분의 비 크롬 브라우저한다.

성능 만! 이 코드는 아마도 여기의 모든 코드보다 10 배 빠를 것입니다. * 모든 브라우저에서 작동하며 메모리에 미치는 영향이 가장 적습니다.

이전 배열을 재사용 할 필요가 없다면 btw 필요한 다른 작업을 고유하게 변환하기 전에 수행하는 것이 가장 빠른 방법 일 것입니다.

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

그럼 당신은 이것을 시도 할 수 있습니다

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]

이 기사를 읽는이 기능을 생각해 냈습니다 ...

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

나는 for 루프를 좋아하지 않는다. while- 루프와 같은 많은 매개 변수가 있습니다. while은 우리가 좋아하는 크롬을 제외한 모든 브라우저에서 가장 빠른 루프입니다.

어쨌든 나는 while을 사용하는 첫 번째 함수를 작성했습니다. 그렇지만 기사에서 찾은 함수보다 약간 빠릅니다.unique2()

다음 단계는 현대 js를 사용합니다. Object.keys 다른 for 루프를 js1.7의 Object.keys로 대체했습니다 (크롬 2 배 빠름); 부족한!. unique3().

이 시점에서 저는 제 고유 한 기능에 정말로 필요한 것이 무엇인지 생각하고있었습니다. 오래된 배열이 필요하지 않습니다. 빠른 기능을 원합니다. 그래서 2 개의 while 루프 + 스플 라이스를 사용했습니다.unique4()

내가 감동했다고 말할 수 없다.

크롬 : 일반적인 초당 150,000 작업이 초당 1,800,000 작업으로 증가했습니다.

즉 : 80,000 op / s vs 3,500,000 op / s

iOS : 18,000 op / s vs 170,000 op / s

사파리 : 80,000 op / s vs 6,000,000 op / s

증명 http://jsperf.com/wgu 또는 더 나은 console.time ... microtime ...을 사용하십시오.

unique5() 이전 배열을 유지하려는 경우 어떻게되는지 보여줄뿐입니다.

당신 Array.prototype이 무엇을하고 있는지 모른다면 사용하지 마십시오 . 나는 방금 복사와 과거를 많이했다. Object.defineProperty(Array.prototype,...,writable:false,enumerable:false})기본 프로토 타입을 생성하려는 경우 사용 합니다. 예 : https://stackoverflow.com/a/20463021/2450730

데모 http://jsfiddle.net/46S7g/

참고 :이 작업을 수행하면 기존 어레이가 파괴 / 독립됩니다.

위의 코드를 읽을 수없는 경우 자바 스크립트 책을 읽거나 짧은 코드에 대한 설명을 참조하십시오. https://stackoverflow.com/a/21353032/2450730

일부는 사용하고 있습니다 indexOf ...하지 마십시오 ... http://jsperf.com/dgfgghfghfghghgfhgfhfghfhgfh

빈 배열

!array.length||toUnique(array); 

여기에 많은 답변이 초보자에게는 유용하지 않을 수 있습니다. 배열 중복 제거가 어려운 경우 프로토 타입 체인 또는 jQuery에 대해 실제로 알고 있습니까?

최신 브라우저에서 깨끗하고 간단한 솔루션은 고유 값 목록으로 설계된 Set에 데이터를 저장 하는 것입니다.

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

는 Array.from배열을 가지고 당신이 멋진 모든 방법 (기능)에 쉽게 액세스 할 수 있도록 배열에 설정 등을 변환하는 데 유용합니다. 같은 일을하는 다른 방법 들도 있습니다 . 그러나 Array.from세트에는 forEach 와 같은 유용한 기능이 많이 있으므로 전혀 필요하지 않을 수도 있습니다. .

이전 Internet Explorer를 지원해야하므로 Set을 사용할 수없는 경우 간단한 방법은 항목이 이미 새 배열에 있는지 확인하면서 새 배열로 항목을 복사하는 것입니다.

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

이 기능을 즉시 재사용 할 수 있도록 기능에 추가해 봅시다.

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

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

        return result;
    }
}

따라서 중복을 제거하려면 이제이 작업을 수행합니다.

var uniqueCars = deduplicate(cars);

그 deduplicate(cars)부분 은 결과 라고하는 것이 됩니다함수가 완료되면 됩니다.

원하는 배열의 이름을 전달하십시오.

["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;
 }, []);

ES6 세트를 사용하여이를 수행 할 수 있습니다.

var duplicatedArray = [1, 2, 3, 4, 5, 1, 1, 1, 2, 3, 4];
var uniqueArray = Array.from(new Set(duplicatedArray));

console.log(uniqueArray);

// 출력은

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

이 프로토 타입 getUnique은 완전히 정확하지 않습니다. 왜냐하면 내가 다음과 같은 배열을 가지고 있다면 ["1",1,2,3,4,1,"foo"]반환 ["1","2","3","4"]되고 "1"문자열이며1 정수입니다. 그들은 달라요.

올바른 해결책은 다음과 같습니다.

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

사용하여 :

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

위의 내용이 생성 ["1",2,3,4,1,"foo"]됩니다.

Array.prototype을 확장하지 않거나 (나쁜 습관이라고 함) jquery / underscore를 사용하지 않고 간단히 filter배열을 만들 수 있습니다 .

마지막 발생을 유지함으로써 :

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

또는 첫 번째 발생 :

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

Java9 ECMAScript 5 이상이며 IE9 +만을 의미하지만 네이티브 HTML / JS (Windows 스토어 앱, Firefox OS, Sencha, Phonegap, Titanium 등)의 개발에는 좋습니다.

마법

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

O (n) 성능 ; 배열이 a및에 있다고 가정합니다 t={}. 여기 설명 (+ 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)]

이것은 가장 간단한 것으로 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]

프로토 타입 프레임 워크를 사용하는 경우 'for'루프를 수행 할 필요가 없으면 다음과 같이 http://www.prototypejs.org/api/array/uniq 를 사용할 수 있습니다 .

var a = Array.uniq();  

중복없이 중복 배열을 생성합니다. 나는 당신의 질문에 걸쳐 배열을 구별하는 방법을 찾고

유니크 ()

나는 사용했다

크기()

그리고 간단한 결과가있었습니다. ps 내가 뭔가 잘못 입력하면 죄송합니다

편집 : 정의되지 않은 레코드를 탈출하려면 추가 할 수 있습니다

콤팩트()

전에 이렇게 :

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

이제 세트를 사용하여 중복을 제거하고 다시 배열로 변환 할 수 있습니다.

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

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

또 다른 해결책은 정렬 및 필터를 사용하는 것입니다

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

0JavaScript에서는 잘못된 값 이기 때문 입니다.

this[i] 배열의 값이 0이거나 다른 잘못된 값이면 거짓입니다.

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
}

배열에서 중복 id 속성을 가진 객체를 제거 해야하는 문제가 약간 다릅니다. 이것은 효과가 있었다.

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

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

console.log(objArr);

가장 간단한 대답은 다음과 같습니다.

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

가브리엘 Silveira가 왜 그런 식으로 함수를 작성했는지는 잘 모르겠지만 축소 기능을 사용하지 않고 나에게도 효과적인 간단한 양식은 다음과 같습니다.

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

또는 CoffeeScript에서 :

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

추가 종속성이 괜찮거나 코드베이스에 이미 라이브러리 중 하나가있는 경우 LoDash (또는 밑줄)를 사용하여 배열에서 중복을 제거 할 수 있습니다.

용법

코드베이스에없는 경우 npm을 사용하여 설치하십시오.

npm install lodash

그런 다음 다음과 같이 사용하십시오.

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

밖:

[ 1, 2, 3 ]

이것은 많은 답변을 받았지만 내 특정 요구를 해결하지 못했습니다.

많은 답변은 다음과 같습니다.

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

그러나 복잡한 객체 배열에는 작동하지 않습니다.

다음과 같은 배열이 있다고 가정 해보십시오.

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

고유 한 이름을 가진 객체를 원하면 다음 array.prototype.findIndex대신 사용해야 합니다 array.prototype.indexOf.

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

에서 Shamasis 데브 브 하타 차르 의 블로그 (O (2N) 시간 복잡도) :

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

에서 폴 아일랜드어 의 블로그 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]

간단한 방법으로 고유 한 배열 값 찾기

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]

우리는 Rafael의 답변 을 잃어버린 것으로 보입니다 . 혼합형 배열이없는 경우 이것은 (최소한 2017 년에) 최고의 솔루션이었습니다 .

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

당신이 경우 어떻게 혼합 형태의 배열을, 당신은 해시 키를 직렬화 할 수 있습니다 :

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

당신이 당신의 배열을로드하는 동안 다른 방법으로 주변의 문제를 해결하기 위해서는 중복이없는 것이 유용 할 수 있습니다, 방법의 설정 목적은 그것을 할 것이지만, 아직 모든 브라우저에서 사용할 수 없습니다. 메모리를 절약하고 내용을 여러 번보아야 할 경우 더 효율적입니다.

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

견본:

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

당신을 제공합니다 set = [1,3,4,2]