Der beste Weg, um herauszufinden, ob ein Element in einem JavaScript-Array ist?

Question

Wie kann man am besten herausfinden, ob ein Objekt in einem Array enthalten ist?

Das ist der beste Weg, den ich kenne:

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

console.log(include([1, 2, 3, 4], 3)); // true
console.log(include([1, 2, 3, 4], 6)); // undefined

Answer 1

Ab ECMAScript 2016 können Sie includes()

arr.includes(obj);

Wenn Sie den IE oder andere ältere Browser unterstützen möchten:

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

EDIT: Dies funktioniert allerdings nicht mit IE6, 7 oder 8. Die beste Abhilfe ist, es selbst zu definieren, wenn es nicht vorhanden ist:

1. Mozillas (ECMA-262) Version:

      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 Jakobus Version:

    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 Version:

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

Answer 2

Wenn Sie jQuery verwenden:

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

Für weitere Informationen: http://api.jquery.com/jQuery.inArray/

Answer 3

Erstens: Umsetzung indexOf in JavaScript für Browser, die diese Funktion noch nicht haben. Zum Beispiel, siehe Erik Arvidssons Aufgebot an Extras (auch die zugehöriger Blogbeitrag ). Und dann können Sie indexOf ohne sich um die Browserunterstützung zu kümmern. Hier ist eine leicht optimierte Version von ihm indexOf Umsetzung:

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

Es wurde geändert, um die Länge zu speichern, so dass sie nicht bei jeder Iteration nachgeschlagen werden muss. Aber der Unterschied ist nicht groß. Eine weniger universell einsetzbare Funktion könnte schneller sein:

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

Ich ziehe es vor, die Standardfunktion zu verwenden und diese Art von Mikro-Optimierung nur dann vorzunehmen, wenn sie wirklich benötigt wird. Aber wenn Sie an der Mikro-Optimierung interessiert sind, habe ich die Benchmarks die roosterononacid in den Kommentaren verlinkt hat, zu Benchmark-Suche in Arrays . Eine vollständige Untersuchung würde Arrays mit verschiedenen Typen und Längen testen und Objekte finden, die an verschiedenen Orten vorkommen.

Answer 4

Wenn das Array unsortiert ist, gibt es nicht wirklich eine bessere Möglichkeit (abgesehen von der Verwendung des oben erwähnten indexOf, was meiner Meinung nach auf dasselbe hinausläuft). Wenn das Array sortiert ist, können Sie eine binäre Suche durchführen, die wie folgt funktioniert:

1. Wählen Sie das mittlere Element des Arrays.
2. Ist das Element, das Sie suchen, größer als das Element, das Sie ausgewählt haben? Wenn ja, haben Sie die untere Hälfte des Feldes eliminiert. Wenn nicht, haben Sie die obere Hälfte eliminiert.
3. Wählen Sie das mittlere Element der verbleibenden Hälfte des Feldes und fahren Sie wie in Schritt 2 fort, wobei Sie die Hälften des verbleibenden Feldes eliminieren. Schließlich werden Sie entweder Ihr Element finden oder kein Feld mehr zum Durchsuchen haben.

Die Zeit für die binäre Suche ist proportional zum Logarithmus der Länge des Arrays, so dass sie viel schneller sein kann als die Suche nach jedem einzelnen Element.

Answer 5

[ ].has(obj)

unter der Annahme, dass .indexOf() wird umgesetzt

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

!!! nicht machen Array.prototype.has=function(){... weil Sie ein aufzählbares Element in jedem Array hinzufügen und js gebrochen ist.

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

die Verwendung von 2nd arg (Flag) erzwingt den Vergleich nach Wert statt nach Referenz

Vergleich roher Objekte

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