一意であることを確認する必要がある数値の配列があります。私はインターネットで以下のコードスニペットを見つけました。配列にゼロが含まれるまで、それはうまく機能します。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配列から重複する値を削除する

同様の質問：

• 配列内のすべての非一意の値（つまり、重複/複数のオカレンス）を取得します

JavaScript 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のindexOf MDNドキュメントで回避策を見つけることができます。

あなたが値の最後に出現を維持したい場合は、シンプルに置き換える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']

のコンストラクタはSet、Arrayなどの反復可能なオブジェクトを受け取り、spread演算子...はセットを配列に変換します。コメントのヒントを提供してくれた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スプレッドシートでは使用できないため、テストできません。

テストの結果は次のとおりです。

{ }ハッシュを使用しているため、object を使用するコードが勝つことを期待していました。テストが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のアヒルのパンチングポストから引用されました-クレジットを提供するのを忘れていました：P

ES6での最短のソリューション： [...new Set( [1, 1, 2] )];

または、（元の質問のように）Arrayプロトタイプを変更する場合：

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

EcmaScript 6は現在（2015年8月）の最新のブラウザーで部分的にのみ実装されていますが、BabelはES6（さらにはES7）をES5にトランスパイルすることで非常に人気があります。そうすれば、今すぐES6コードを書くことができます！

...意味がわからない場合は、スプレッド演算子と呼ばれます。MDNから：«スプレッド演算子を使用すると、複数の引数（関数呼び出しの場合）または複数の要素（配列リテラルの場合）が期待される場所で式を展開できます»。Setは反復可能であり（一意の値しか持てないため）、spreadオペレーターはSetを展開して配列を埋めます。

ES6を学ぶためのリソース：

• アクセルラウシュマイヤー博士による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;
}

これは、ほとんどの非Chromeブラウザーで上記の方法よりも高速です。

パフォーマンスのみ！このコードは、ここにあるすべてのコードよりもおそらく10倍速く *すべてのブラウザで機能し、メモリへの影響も最小限です。

古い配列を再利用する必要がない場合は、ここでそれを一意に変換する前に、必要な他の操作を行ってください。これはおそらくこれを行う最も速い方法ですが、これも非常に短い方法です。

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

感動したと言ってもダメ。

クロム：通常の1秒あたり150,000オペレーションは、1秒あたり1,800,000オペレーションにジャンプしました。

つまり、 80,000 op / s対3,500,000 op / s

iOS： 18,000 op / s対170,000 op / s

サファリ： 80,000オペレーション/秒vs 6,000,000オペレーション/秒

証明 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/

注：この操作の後、古いアレイは破棄されるか、固有のものになります。

上記のコードが読めない場合は、javascriptの本を読んでください。短いコードについての説明もいくつかあります。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)部分がresultという名前になります。

好きな配列の名前を渡してください。

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

まあ、それはIE9 +のみを意味するJavaScript ECMAScript 5+だけですが、ネイティブ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]

Prototypeフレームワークを使用している場合は、「for」ループを実行する必要はありません。次のようにhttp://www.prototypejs.org/api/array/uniqを使用できます。

var a = Array.uniq();  

これにより、重複のない重複配列が生成されます。個別の配列レコードをカウントする方法を検索する質問に出くわしたので、

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

それ0は、JavaScriptの偽の値だからです。

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]

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

追加の依存関係に問題がない場合、またはコードベースにすでにライブラリの1つがある場合は、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]

数年間、受け入れられた回答であったラファエルの回答を失ったようです。これは（少なくとも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;
}

逆の方法で問題に対処するには、配列をロードするときに重複がないようにすると便利です。Setオブジェクトが行う方法と同じですが、まだすべてのブラウザーで使用できるわけではありません。それはメモリを節約し、その内容を何度も見る必要がある場合により効率的です。

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]