webdevqa.jp.net

項目がJavaScriptの配列に含まれているかどうかを調べるための最良の方法は?

オブジェクトが配列内にあるかどうかを見つけるための最良の方法は何ですか?

これは私が知っている最善の方法です:

function include(arr, obj) {
    for(var i=0; i<arr.length; i++) {
        if (arr[i] == obj) return true;
    }
}

include([1,2,3,4], 3); // true
include([1,2,3,4], 6); // undefined
738
zimbatm

ECMAScript 2016以降、 includes() を使用できます。

arr.includes(obj);

IEまたは他の古いブラウザをサポートしたい場合は、次の手順を実行します。

function include(arr,obj) {
    return (arr.indexOf(obj) != -1);
}

編集:これはIE 6、7または8でも動作しません。最善の回避策は、存在しない場合は自分で定義することです。

  1. Mozillaの (ECMA-262)バージョン:

      if (!Array.prototype.indexOf)
      {
    
           Array.prototype.indexOf = function(searchElement /*, fromIndex */)
    
        {
    
    
        "use strict";
    
        if (this === void 0 || 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 > 0)
        {
          n = Number(arguments[1]);
          if (n !== n)
            n = 0;
          else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0))
            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;
      };
    
    }
    
  2. Daniel James のバージョン:

    if (!Array.prototype.indexOf) {
      Array.prototype.indexOf = function (obj, fromIndex) {
        if (fromIndex == null) {
            fromIndex = 0;
        } else if (fromIndex < 0) {
            fromIndex = Math.max(0, this.length + fromIndex);
        }
        for (var i = fromIndex, j = this.length; i < j; i++) {
            if (this[i] === obj)
                return i;
        }
        return -1;
      };
    }
    
  3. roosteronacid のバージョン:

    Array.prototype.hasObject = (
      !Array.indexOf ? function (o)
      {
        var l = this.length + 1;
        while (l -= 1)
        {
            if (this[l - 1] === o)
            {
                return true;
            }
        }
        return false;
      } : function (o)
      {
        return (this.indexOf(o) !== -1);
      }
    );
    
682
Vinko Vrsalovic

JQueryを使用している場合

$.inArray(5 + 5, [ "8", "9", "10", 10 + "" ]);

詳細情報: http://api.jquery.com/jQuery.inArray/ /

207
GerManson

まず、まだそれを持っていないブラウザのためにJavaScriptでindexOfを実装してください。例えば、 Erik Arvidssonの配列extras を参照してください(また、 関連ブログ記事 )。そして、ブラウザのサポートを気にせずにindexOfを使うことができます。これは彼のindexOfの実装を少し最適化したものです。

if (!Array.prototype.indexOf) {
    Array.prototype.indexOf = function (obj, fromIndex) {
        if (fromIndex == null) {
            fromIndex = 0;
        } else if (fromIndex < 0) {
            fromIndex = Math.max(0, this.length + fromIndex);
        }
        for (var i = fromIndex, j = this.length; i < j; i++) {
            if (this[i] === obj)
                return i;
        }
        return -1;
    };
}

繰り返しごとに調べる必要がないように、長さを格納するように変更されました。しかし違いはそれほど大きくありません。汎用性の低い関数の方が速いかもしれません。

var include = Array.prototype.indexOf ?
    function(arr, obj) { return arr.indexOf(obj) !== -1; } :
    function(arr, obj) {
        for(var i = -1, j = arr.length; ++i < j;)
            if(arr[i] === obj) return true;
        return false;
    };

私は標準関数を使用し、それが本当に必要とされるときのためにこの種のマイクロ最適化を残すことを好みます。しかし、もしあなたがマイクロ最適化に興味があるならば、私は ベンチマーク そのroosterononacidがリンクされている ベンチマーク検索を配列 に適応させました。しかし、それらはかなり粗雑です。詳細な調査では、さまざまなタイプ、さまざまな長さの配列をテストし、さまざまな場所に存在するオブジェクトを見つけることができます。

33
Daniel James

配列がソートされていないのであれば、(上記のindexOfを使用することは別として)同じ方法ではありませんが、それ以上の方法はありません。配列がソートされている場合は、二分検索を実行できます。これは次のように機能します。

  1. 配列の中央の要素を選びます。
  2. あなたが探している要素はあなたが選んだ要素より大きいですか?もしそうなら、あなたは配列の下半分を排除しました。そうでなければ、あなたは上半分を排除しました。
  3. 残りの配列の半分を削除し、残りの半分の配列を削除します。最終的には、あなたは自分の要素を見つけるか、見通すための配列が残っていないことになります。

バイナリ検索は、配列の長さの対数に比例して時間内に実行されるため、個々の要素を調べるよりもはるかに高速です。

11
assortedslog

[] .has(obj)

.indexOf()が実装されていると仮定

Object.defineProperty( Array.prototype,'has',
{
    value:function(o, flag){
    if (flag === undefined) {
        return this.indexOf(o) !== -1;
    } else {   // only for raw js object
        for(var v in this) {
            if( JSON.stringify(this[v]) === JSON.stringify(o)) return true;
        }
        return false;                       
    },
    // writable:false,
    // enumerable:false
})

!!!すべての配列に列挙可能な要素を追加するとjsが壊れるので、Array.prototype.has=function(){...を作成しないでください。

//use like          
[22 ,'a', {prop:'x'}].has(12) // false
["a","b"].has("a") //  true

[1,{a:1}].has({a:1},1) // true
[1,{a:1}].has({a:1}) // false

2番目の引数(flag)を使用すると、参照ではなく値で比較が強制されます。

生オブジェクトの比較

[o1].has(o2,true) // true if every level value is same
10
bortunac

それはあなたの目的によります。 Web用にプログラムする場合は、indexOfを避けてください。これはInternet Explorer 6ではサポートされていません(まだ使用されていることが多いです)。

if (yourArray.indexOf !== undefined) result = yourArray.indexOf(target);
else result = customSlowerSearch(yourArray, target);

indexOfはおそらくネイティブコードでコーディングされているので、JavaScriptでできることよりも高速です(配列が適切な場合はバイナリ検索/二分法を除く)。注意:これは好みの問題ですが、真のブール値を返すために、ルーチンの最後にreturn false;を実行します。

6
PhiLho

ここにあなたのためのメタ知識があります - あなたがArrayを使って何ができるか知りたいのなら、ドキュメントをチェックしてください - ここにMozillaのためのArrayページがあります

https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array

Javascript 1.6で追加されたindexOfへの参照があります。

5
Paul Dixon

オブジェクトがjavascriptで配列であるかどうかを確認するための堅牢な方法は、ここで詳しく説明されています。

これは、私がutils = {} ʻcontainer'にアタッチする xa.js フレームワークからの二つの関数です。これらはアレイを正しく検出するのに役立ちます。

var utils = {};

/**
 * utils.isArray
 *
 * Best guess if object is an array.
 */
utils.isArray = function(obj) {
     // do an instanceof check first
     if (obj instanceof Array) {
         return true;
     }
     // then check for obvious falses
     if (typeof obj !== 'object') {
         return false;
     }
     if (utils.type(obj) === 'array') {
         return true;
     }
     return false;
 };

/**
 * utils.type
 *
 * Attempt to ascertain actual object type.
 */
utils.type = function(obj) {
    if (obj === null || typeof obj === 'undefined') {
        return String (obj);
    }
    return Object.prototype.toString.call(obj)
        .replace(/\[object ([a-zA-Z]+)\]/, '$1').toLowerCase();
};

それからもしあなたがオブジェクトが配列の中にあるかどうかをチェックしたいのなら、私はこのコードも含めるでしょう:

/**
 * Adding hasOwnProperty method if needed.
 */
if (typeof Object.prototype.hasOwnProperty !== 'function') {
    Object.prototype.hasOwnProperty = function (prop) {
        var type = utils.type(this);
        type = type.charAt(0).toUpperCase() + type.substr(1);
        return this[prop] !== undefined
            && this[prop] !== window[type].prototype[prop];
    };
}

そして最後にこのin_array関数:

function in_array (needle, haystack, strict) {
    var key;

    if (strict) {
        for (key in haystack) {
            if (!haystack.hasOwnProperty[key]) continue;

            if (haystack[key] === needle) {
                return true;
            }
        }
    } else {
        for (key in haystack) {
            if (!haystack.hasOwnProperty[key]) continue;

            if (haystack[key] == needle) {
                return true;
            }
        }
    }

    return false;
}
4