JavaScript 配列に値が含まれているかどうかを確認する最も簡潔で効率的な方法は何ですか?
これは私が知っている唯一の方法です：
function contains(a, obj) {
for (var i = 0; i < a.length; i++) {
if (a[i] === obj) {
return true;
}
}
return false;
}
これを達成するためのより良い、より簡潔な方法はありますか?
最新のブラウザーには がありArray#includes、これはまさにそれを行い、IE を除くすべてのユーザーによって広くサポートされています。
console.log(['joe', 'jane', 'mary'].includes('jane')); //trueを使用することもできますArray#indexOf。これは直接的ではありませんが、古いブラウザー用のポリフィルは必要ありません。
console.log(['joe', 'jane', 'mary'].indexOf('jane') >= 0); //true多くのフレームワークも同様の方法を提供しています。
$.inArray(value, array, [fromIndex])_.contains(array, value)としてもエイリアスされます)_.include_.includesdojo.indexOf(array, value, [fromIndex, findLast])array.indexOf(value)array.indexOf(value)findValue(array, value)array.indexOf(value)Ext.Array.contains(array, value)_.includes(array, value, [from])( _.contains4.0.0 より前)R.includes(value, array)これを関数として実装するフレームワークもあれば、関数を配列プロトタイプに追加するフレームワークもあります。
2019 年からの更新: この回答は 2008 年 (11 歳!) のものであり、最新の JS の使用には関係ありません。約束されたパフォーマンスの向上は、当時のブラウザーで行われたベンチマークに基づいていました。最新の JS 実行コンテキストには関係ない可能性があります。簡単な解決策が必要な場合は、他の回答を探してください。最高のパフォーマンスが必要な場合は、関連する実行環境で自分自身をベンチマークしてください。
他の人が言ったように、配列を反復するのがおそらく最良の方法ですが、減少するループが JavaScript で反復する最速の方法であることが証明されています。whileしたがって、次のようにコードを書き直すことをお勧めします。
function contains(a, obj) {
var i = a.length;
while (i--) {
if (a[i] === obj) {
return true;
}
}
return false;
}
もちろん、Array プロトタイプを拡張することもできます。
Array.prototype.contains = function(obj) {
var i = this.length;
while (i--) {
if (this[i] === obj) {
return true;
}
}
return false;
}
そして今、あなたは単に以下を使うことができます:
alert([1, 2, 3].contains(2)); // => true
alert([1, 2, 3].contains('2')); // => false
indexOfおそらくですが、これは「ECMA-262 標準の JavaScript 拡張機能であるため、標準の他の実装には存在しない可能性があります」。
例：
[1, 2, 3].indexOf(1) => 0
["foo", "bar", "baz"].indexOf("bar") => 1
[1, 2, 3].indexOf(4) => -1
AFAICS Microsoft はこれに代わるものを提供していませんが、必要に応じて Internet Explorer (および をサポートしていない他のブラウザーindexOf)の配列に同様の機能を追加できます。 ）。
次のような配列を定義したとしましょう。
const array = [1, 2, 3, 4]
以下は、3そこにあるかどうかを確認する3つの方法です。それらはすべて、またはのいずれtrueかを返しますfalse。
array.includes(3) // true
// Prefixing the method with '_' to avoid name clashes
Object.defineProperty(Array.prototype, '_includes', { value: function (v) { return this.indexOf(v) !== -1 }})
array._includes(3) // true
const includes = (a, v) => a.indexOf(v) !== -1
includes(array, 3) // true
のJavaScript 1.6 互換の実装を次に示しArray.indexOfます。
if (!Array.indexOf) {
Array.indexOf = [].indexOf ?
function(arr, obj, from) {
return arr.indexOf(obj, from);
} :
function(arr, obj, from) { // (for IE6)
var l = arr.length,
i = from ? parseInt((1 * from) + (from < 0 ? l : 0), 10) : 0;
i = i < 0 ? 0 : i;
for (; i < l; i++) {
if (i in arr && arr[i] === obj) {
return i;
}
}
return -1;
};
}
JavaScript オブジェクトを拡張することは、新しいプロパティ (カスタム メソッド) をループにArray導入して既存のスクリプトを壊す可能性があるため、非常に悪い考えです。for-in数年前、Prototypeライブラリの作成者は、この種のものを削除するためにライブラリの実装を再設計する必要がありました。
ページで実行されている他の JavaScript との互換性について心配する必要がない場合は、それを選択してください。
今日 2020.01.07 私は、選択した 15 のソリューションについて、Chrome v78.0.0、Safari v13.0.4、および Firefox v71.0.0 上の MacOs HighSierra 10.13.6 でテストを実行しました。結論
JSON、Setそして驚くべきことに (K,N,O)に基づくソリューションfindは、すべてのブラウザで最も遅いincludes(F) は chrome でのみ高速ですfor(C,D) および(G,H)に基づくソリューションindexOfは、小規模および大規模な配列のすべてのブラウザーで非常に高速であるため、おそらく効率的なソリューションの最良の選択です。forまた、検索された要素が配列の長さの 66% の位置にあるときに大きな配列のテストを実行し、 (C、D、E) に基づくソリューションでも同様の結果が得られます (~630 ops/秒 - ただし、safari と firefox の E は 10- C および D よりも 20% 遅い)
10 要素の配列と 100 万要素の配列の 2 つのテスト ケースを実行します。どちらの場合も、検索された要素を配列の中央に置きます。
let log = (name,f) => console.log(`${name}: 3-${f(arr,'s10')} 's7'-${f(arr,'s7')} 6-${f(arr,6)} 's3'-${f(arr,'s3')}`)
let arr = [1,2,3,4,5,'s6','s7','s8','s9','s10'];
//arr = new Array(1000000).fill(123); arr[500000]=7;
function A(a, val) {
var i = -1;
var n = a.length;
while (i++<n) {
if (a[i] === val) {
return true;
}
}
return false;
}
function B(a, val) {
var i = a.length;
while (i--) {
if (a[i] === val) {
return true;
}
}
return false;
}
function C(a, val) {
for (var i = 0; i < a.length; i++) {
if (a[i] === val) return true;
}
return false;
}
function D(a,val)
{
var len = a.length;
for(var i = 0 ; i < len;i++)
{
if(a[i] === val) return true;
}
return false;
}
function E(a, val){
var n = a.length-1;
var t = n/2;
for (var i = 0; i <= t; i++) {
if (a[i] === val || a[n-i] === val) return true;
}
return false;
}
function F(a,val) {
return a.includes(val);
}
function G(a,val) {
return a.indexOf(val)>=0;
}
function H(a,val) {
return !!~a.indexOf(val);
}
function I(a, val) {
return a.findIndex(x=> x==val)>=0;
}
function J(a,val) {
return a.some(x=> x===val);
}
function K(a, val) {
const s = JSON.stringify(val);
return a.some(x => JSON.stringify(x) === s);
}
function L(a,val) {
return !a.every(x=> x!==val);
}
function M(a, val) {
return !!a.find(x=> x==val);
}
function N(a,val) {
return a.filter(x=>x===val).length > 0;
}
function O(a, val) {
return new Set(a).has(val);
}
log('A',A);
log('B',B);
log('C',C);
log('D',D);
log('E',E);
log('F',F);
log('G',G);
log('H',H);
log('I',I);
log('J',J);
log('K',K);
log('L',L);
log('M',M);
log('N',N);
log('O',O);This shippet only presents functions used in performance tests - it not perform tests itself!小さい配列 - 10 要素
ここでマシンでテストを実行できます
大きな配列 - 1.000.000 要素
ここでマシンでテストを実行できます
一発ギャグ：
function contains(arr, x) {
return arr.filter(function(elem) { return elem == x }).length > 0;
}
少し考えてみると、この呼び出しを何度も行う場合は、連想配列の Map を使用して、ハッシュ関数を使用してルックアップを行う方がはるかに効率的です。
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map
私は以下を使用します：
Array.prototype.contains = function (v) {
return this.indexOf(v) > -1;
}
var a = [ 'foo', 'bar' ];
a.contains('foo'); // true
a.contains('fox'); // false
function contains(a, obj) {
return a.some(function(element){return element == obj;})
}
Array.prototype.some()は、第 5 版で ECMA-262 標準に追加されました。
JavaScript 1.6 以降 (Firefox 1.5 以降) を使用している場合は、Array.indexOfを使用できます。そうしないと、元のコードに似たものになってしまうと思います。
できればより高速な双方向indexOf/lastIndexOf代替
新しいメソッドインクルードは非常に優れていますが、現時点ではサポートは基本的にゼロです。
遅い indexOf/lastIndexOf 関数を置き換える方法を考えていたのは長い間です。
上位の回答を見ると、パフォーマンスの高い方法がすでに見つかっています。それらの中からcontains、@Damir Zekic によって投稿された最も速い関数を選びました。しかし、ベンチマークは2008年のものであり、時代遅れであるとも述べています.
私も よりも好きですwhileがfor、特別な理由はありませんが、 for ループを使用して関数の記述を終了しました。で行うこともできますwhile --。
実行中に配列の両側をチェックすると、反復がはるかに遅くなるかどうかに興味がありました。どうやらいいえ、したがって、この関数は上位投票のものよりも約 2 倍高速です。明らかに、ネイティブよりも高速です。これは、検索している値が配列の先頭にあるのか末尾にあるのかがわからない現実世界の環境です。
配列に値をプッシュしたことがわかっている場合は、おそらく lastIndexOf を使用することが最善の解決策ですが、大きな配列を移動する必要があり、結果がどこにでもある可能性がある場合、これは物事を高速化するための確実な解決策になる可能性があります。
双方向 indexOf/lastIndexOf
function bidirectionalIndexOf(a, b, c, d, e){
for(c=a.length,d=c*1; c--; ){
if(a[c]==b) return c; //or this[c]===b
if(a[e=d-1-c]==b) return e; //or a[e=d-1-c]===b
}
return -1
}
//Usage
bidirectionalIndexOf(array,'value');
http://jsperf.com/bidirectionalindexof
テストとして、100k エントリの配列を作成しました。
3 つのクエリ: 配列の先頭、中間、末尾。
これも興味深いものであり、パフォーマンスをテストしていただければ幸いです。
注: ご覧のとおりcontains、indexOf と lastIndexOf の出力を反映するように関数を少し変更しました (基本的trueにindexとfalseを使用-1)。それはそれを害するべきではありません。
Object.defineProperty(Array.prototype,'bidirectionalIndexOf',{value:function(b,c,d,e){
for(c=this.length,d=c*1; c--; ){
if(this[c]==b) return c; //or this[c]===b
if(this[e=d-1-c] == b) return e; //or this[e=d-1-c]===b
}
return -1
},writable:false, enumerable:false});
// Usage
array.bidirectionalIndexOf('value');
この関数は、true または false、さらにはオブジェクト、文字列などを返すように簡単に変更することもできます。
そして、ここにwhileバリアントがあります：
function bidirectionalIndexOf(a, b, c, d){
c=a.length; d=c-1;
while(c--){
if(b===a[c]) return c;
if(b===a[d-c]) return d-c;
}
return c
}
// Usage
bidirectionalIndexOf(array,'value');
配列内の反映されたインデックスを取得する単純な計算は非常に単純であるため、実際のループ反復を実行するよりも 2 倍高速であると思います。
これは反復ごとに 3 つのチェックを行う複雑な例ですが、これはコードの速度低下の原因となるより長い計算でのみ可能です。
function inArray(elem,array)
{
var len = array.length;
for(var i = 0 ; i < len;i++)
{
if(array[i] == elem){return i;}
}
return -1;
}
見つかった場合は配列インデックスを返し、見つからなかった場合は -1 を返します
これをarray.indexOf(x)!=-1行うための最も簡潔な方法ですが（そして、Internet Explorer以外のブラウザーで10年以上サポートされています...）、それはO（1）ではなく、ひどいO（N）です。配列が変更されない場合は、配列をハッシュテーブルに変換してから、table[x]!==undefinedまたは===undefined：を実行できます。
Array.prototype.toTable = function() {
var t = {};
this.forEach(function(x){t[x]=true});
return t;
}
デモ：
var toRemove = [2,4].toTable();
[1,2,3,4,5].filter(function(x){return toRemove[x]===undefined})
（残念ながら、Array.prototype.containsを作成して配列を「フリーズ」し、ハッシュテーブルをthis._cacheに2行で格納できますが、後で配列を編集することを選択した場合、これは間違った結果になります。JavaScriptには不十分なフックがあります。たとえばPythonとは異なり、この状態を維持できます。）
「has()」メソッドを持つSetを使用できます。
function contains(arr, obj) {
var proxy = new Set(arr);
if (proxy.has(obj))
return true;
else
return false;
}
var arr = ['Happy', 'New', 'Year'];
console.log(contains(arr, 'Happy'));OK、コードを最適化して結果を得ることができます!
これを行うには、よりクリーンで優れた方法がたくさんありますが、パターンを取得して、 を使用してそれに適用したかっただけJSON.stringifyで、あなたの場合は次のようにします。
function contains(a, obj) {
for (var i = 0; i < a.length; i++) {
if (JSON.stringify(a[i]) === JSON.stringify(obj)) {
return true;
}
}
return false;
}
1 つのパラメーターがあります: オブジェクトの配列番号です。配列内の各オブジェクトには、x と y で示される 2 つの整数プロパティがあります。この関数は、条件を満たす配列内のすべてのオブジェクトの数を返す必要があります。numbers.x == numbers.y
var numbers = [ { x: 1, y: 1 },
{ x: 2, y: 3 },
{ x: 3, y: 3 },
{ x: 3, y: 4 },
{ x: 4, y: 5 } ];
var count = 0;
var n = numbers.length;
for (var i =0;i<n;i++)
{
if(numbers[i].x==numbers[i].y)
{count+=1;}
}
alert(count);このトリックを使用することもできます。
var arrayContains = function(object) {
return (serverList.filter(function(currentObject) {
if (currentObject === object) {
return currentObject
}
else {
return false;
}
}).length > 0) ? true : false
}
プロトタイプがそれを行う方法は次のとおりです。
/**
* Array#indexOf(item[, offset = 0]) -> Number
* - item (?): A value that may or may not be in the array.
* - offset (Number): The number of initial items to skip before beginning the
* search.
*
* Returns the position of the first occurrence of `item` within the array — or
* `-1` if `item` doesn't exist in the array.
**/
function indexOf(item, i) {
i || (i = 0);
var length = this.length;
if (i < 0) i = length + i;
for (; i < length; i++)
if (this[i] === item) return i;
return -1;
}
また、接続方法については、こちらを参照してください。
使用する：
Array.prototype.contains = function(x){
var retVal = -1;
// x is a primitive type
if(["string","number"].indexOf(typeof x)>=0 ){ retVal = this.indexOf(x);}
// x is a function
else if(typeof x =="function") for(var ix in this){
if((this[ix]+"")==(x+"")) retVal = ix;
}
//x is an object...
else {
var sx=JSON.stringify(x);
for(var ix in this){
if(typeof this[ix] =="object" && JSON.stringify(this[ix])==sx) retVal = ix;
}
}
//Return False if -1 else number if numeric otherwise string
return (retVal === -1)?false : ( isNaN(+retVal) ? retVal : +retVal);
}
これが最善の方法ではないことはわかっていますが、オブジェクト間で相互作用するネイティブの IComparable 方法がないため、これは配列内の 2 つのエンティティを比較するのに最も近い方法だと思います。また、Array オブジェクトを拡張するのは賢明なことではないかもしれませんが、場合によっては問題ありません (それとトレードオフを認識している場合)。
他の人が述べたように、使用できArray.indexOfますが、すべてのブラウザーで使用できるわけではありません。https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/indexOfのコードは、古いブラウザでも同じように動作します。
indexOf は ECMA-262 標準に最近追加されたものです。そのため、すべてのブラウザに存在するとは限りません。これを回避するには、スクリプトの先頭に次のコードを挿入し、indexOf をネイティブにサポートしていない実装で使用できるようにします。このアルゴリズムは、Object、TypeError、Number、Math.floor、Math.abs、および Math.max が元の値を持っていると仮定して、ECMA-262 第 5 版で指定されているものとまったく同じです。
if (!Array.prototype.indexOf) {
Array.prototype.indexOf = function (searchElement /*, fromIndex */ ) {
"use strict";
if (this == null) {
throw new TypeError();
}
var t = Object(this);
var len = t.length >>> 0;
if (len === 0) {
return -1;
}
var n = 0;
if (arguments.length > 1) {
n = Number(arguments[1]);
if (n != n) { // shortcut for verifying if it's NaN
n = 0;
} else if (n != 0 && n != Infinity && n != -Infinity) {
n = (n > 0 || -1) * Math.floor(Math.abs(n));
}
}
if (n >= len) {
return -1;
}
var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);
for (; k < len; k++) {
if (k in t && t[k] === searchElement) {
return k;
}
}
return -1;
}
}
提出された回答を調べたところ、参照を介してオブジェクトを検索した場合にのみ適用されることがわかりました。参照オブジェクトの比較による単純な線形検索。
しかし、オブジェクトへの参照がない場合、配列内で正しいオブジェクトを見つけるにはどうすればよいでしょうか? 各オブジェクトと直線的に深く比較する必要があります。リストが大きすぎて、その中のオブジェクトが非常に大きく、大きなテキストが含まれていると想像してください。配列内の要素の数とサイズに応じて、パフォーマンスが大幅に低下します。
オブジェクトを文字列化してネイティブ ハッシュ テーブルに入れることはできますが、これらのキーを記憶することでデータの冗長性が得られ、JavaScript が「for i in obj」のためにキーを保持し、オブジェクトが存在するかどうかのみを確認する必要があります。つまり、 、あなたは鍵を持っています。
私はしばらくの間、JSON Schema Validator を構築する際にこれについて考え、ネイティブ ハッシュ テーブルの単純なラッパーを考案しました。これは、唯一のハッシュ テーブルの実装に似ていますが、いくつかの最適化の例外はネイティブ ハッシュ テーブルに処理を任せました。パフォーマンスのベンチマークだけが必要です... 詳細とコードはすべて私のブログにあります: http://stamat.wordpress.com/javascript-quickly-find-very-large-objects-in-a-large-array/ すぐにベンチマーク結果を投稿します。
完全なソリューションは次のように機能します。
var a = {'a':1,
'b':{'c':[1,2,[3,45],4,5],
'd':{'q':1, 'b':{'q':1, 'b':8},'c':4},
'u':'lol'},
'e':2};
var b = {'a':1,
'b':{'c':[2,3,[1]],
'd':{'q':3,'b':{'b':3}}},
'e':2};
var c = "Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.";
var hc = new HashCache([{a:3, b:2, c:5}, {a:15, b:2, c:'foo'}]); //init
hc.put({a:1, b:1});
hc.put({b:1, a:1});
hc.put(true);
hc.put('true');
hc.put(a);
hc.put(c);
hc.put(d);
console.log(hc.exists('true'));
console.log(hc.exists(a));
console.log(hc.exists(c));
console.log(hc.exists({b:1, a:1}));
hc.remove(a);
console.log(hc.exists(c));
同様のこと：「検索ラムダ」で最初の要素を見つけます：
Array.prototype.find = function(search_lambda) {
return this[this.map(search_lambda).indexOf(true)];
};
使用法：
[1,3,4,5,8,3,5].find(function(item) { return item % 2 == 0 })
=> 4
コーヒースクリプトでも同じ：
Array.prototype.find = (search_lambda) -> @[@map(search_lambda).indexOf(true)]
簡単な解決策: ES6 Features " includes " メソッド
let arr = [1, 2, 3, 2, 3, 2, 3, 4];
arr.includes(2) // true
arr.includes(93) // false
文字通り：
(Firefox v3.6 を使用しfor-in、前述の注意事項があります (ただし、以下の使用はfor-inまさにこの目的のために推奨される可能性があります!つまり、プロパティ インデックスを介して実際に存在する配列要素を列挙します (ただし、特に、配列lengthプロパティはプロパティfor-inリスト!)))
(即時モードのブラウザー テスト用に、次の完全な URI をドラッグ アンド ドロップします。)
function ObjInRA(ra){var has=false; for(i in ra){has=true; break;} return has;}
function check(ra){
return ['There is ',ObjInRA(ra)?'an':'NO',' object in [',ra,'].'].join('')
}
alert([
check([{}]), check([]), check([,2,3]),
check(['']), '\t (a null string)', check([,,,])
].join('\n'));
以下が表示されます。
There is an object in [[object Object]].
There is NO object in [].
There is an object in [,2,3].
There is an object in [].
(a null string)
There is NO object in [,,].
しわ: 「特定の」オブジェクトを探している場合は、次の点を考慮してください。
JavaScript:alert({}!={}); alert({}!=={});
したがって：
obj = {prop:"value"};
ra1 = [obj];
ra2 = [{prop:"value"}];
alert(ra1[0] == obj);
alert(ra2[0] == obj);
多くの場合、文字どおりのエンティティとしてra2「含む」と見なされます。obj{prop:"value"}
非常に粗く、初歩的で、ナイーブな (コードでは資格強化が必要なため) ソリューション:
obj={prop:"value"}; ra2=[{prop:"value"}];
alert(
ra2 . toSource() . indexOf( obj.toSource().match(/^.(.*).$/)[1] ) != -1 ?
'found' :
'missing' );
ref: JavaScript 配列内のオブジェクトの検索 を参照してください。
ちょうど別のオプション
// usage: if ( ['a','b','c','d'].contains('b') ) { ... }
Array.prototype.contains = function(value){
for (var key in this)
if (this[key] === value) return true;
return false;
}
カスタムメソッドでjavascript配列オブジェクトをオーバーロードすると、他のjavascriptの動作が中断され、予期しない動作が発生する可能性があるため、注意してください。