Wie kann ich überprüfen, ob ein array umfasst ein Objekt in JavaScript?

Update: Wie @orip erwähnt in den Kommentaren, die verlinkten benchmark wurde im Jahr 2008 getan, so dass die Ergebnisse möglicherweise nicht relevant für moderne Browser. Allerdings werden Sie wahrscheinlich benötigen, diese zur Unterstützung von nicht in modernen Browsern überhaupt ist und Sie wahrscheinlich noch nicht aktualisiert worden seit. Testen Sie immer für sich selbst.

Wie schon andere gesagt haben, wird die iteration durch das array ist wohl der beste Weg, aber es hat sich bewährt, dass eine Verringerung while Schleife ist der Schnellste Weg zur Iteration in JavaScript. So möchten Sie vielleicht ändern Sie Ihren code wie folgt:

function contains(a, obj) {
    var i = a.length;
    while (i--) {
       if (a[i] === obj) {
           return true;
       }
    }
    return false;
}

Natürlich können Sie auch verlängern-Array-Prototyp:

Array.prototype.contains = function(obj) {
    var i = this.length;
    while (i--) {
        if (this[i] === obj) {
            return true;
        }
    }
    return false;
}

Und jetzt können Sie verwenden Sie einfach die folgende:

alert([1, 2, 3].contains(2)); //=> true
alert([1, 2, 3].contains('2')); //=> false

InformationsquelleAutor Damir Zekić

ECMAScript 7 stellt Array.der Prototyp.includes.

Es kann z.B. so verwendet werden:

[1, 2, 3].includes(2); //true
[1, 2, 3].includes(4); //false

Er akzeptiert auch ein optionales zweites argument fromIndex:

[1, 2, 3].includes(3, 3); //false
[1, 2, 3].includes(3, -1); //true

Im Gegensatz zu indexOf verwendet Strikte Gleichheit Vergleich, includes vergleicht mit SameValueZero Gleichheit Algorithmus. Das bedeutet, dass Sie kann erkennen, wenn ein array enthält eine NaN:

[1, 2, NaN].includes(NaN); //true

Auch im Gegensatz zu indexOf, includes nicht überspringen fehlende Indizes:

new Array(5).includes(undefined); //true

Derzeit ist es noch ein Entwurf, aber können polyfilled, damit es funktioniert auf allen Browsern.

InformationsquelleAutor Oriol

Den top-Antworten davon ausgehen, primitive Typen, aber wenn Sie möchten, um herauszufinden, ob ein array enthält ein Objekt mit einer gewissen Eigenschaft, Array.der Prototyp.einige() ist eine sehr elegante Lösung:

const items = [ {a: '1'}, {a: '2'}, {a: '3'} ]

items.some(item => item.a === '3')  //returns true
items.some(item => item.a === '4')  //returns false

Das schöne daran ist, dass die iteration abgebrochen wird, sobald das element gefunden wird, damit unnötige iterationszyklen gespeichert werden.

Auch, es passt gut in eine if - Anweisung, da es ein boolean zurückgibt:

if (items.some(item => item.a === '3')) {
  //do something
}

* Als jamess wies darauf hin, in den Kommentar, wie von heute, September 2018, Array.prototype.some() ist vollständig unterstützt: caniuse.com support Tabelle

InformationsquelleAutor Michael

Verwenden:

function isInArray(array, search)
{
    return array.indexOf(search) >= 0;
}

//Usage
if(isInArray(my_array, "my_value"))
{
    //...
}

InformationsquelleAutor Matías Cánepa

Thinking out of the box für einen zweiten, wenn Sie diesen Aufruf viele, viele Male, es ist weitaus effizienter zu nutzen assoziatives array eine Map zu tun-suchen unter Verwendung einer hash-Funktion.

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

InformationsquelleAutor MattMcKnight

Benutze ich folgende:

Array.prototype.contains = function (v) {
    return this.indexOf(v) > -1;
}

var a = [ 'foo', 'bar' ];

a.contains('foo'); //true
a.contains('fox'); //false

InformationsquelleAutor Eduardo Cuomo

Eine hoffentlich schnellere bidirektionale indexOf /lastIndexOf alternative

2015

Während die neue Methode enthält ist sehr nett, der support ist gleich null jetzt.

Es ist lange, dass ich dachte, der Weg zu ersetzen, der langsam indexOf/lastIndexOf Funktionen.

Performant Weg bereits gefunden wurde, einen Blick auf die top-Antworten. Aus diesen wählte ich die contains Funktion gepostet von @Damir Zekic, das sollte der Schnellste. Aber es zeigt auch, dass die benchmarks sind von 2008 und damit veraltet sind.

Ich auch lieber while über for, aber für keinen bestimmten Grund, ich beendete das schreiben der Funktion mit einer for-Schleife. Es könnte auch mit einem while --.

War ich gespannt, ob die iteration war viel langsamer, wenn ich überprüfen Sie beide Seiten der array, während es zu tun. Anscheinend nicht, und so ist diese Funktion, um zwei mal schneller als die top-stimmten lieben. Natürlich, es ist auch schneller als der einheimische. Diese in einer realen Umgebung, wo man nie weiß, ob der Wert, den Sie suchen ist am Anfang oder am Ende des Arrays.

Wenn Sie wissen, dass Sie gerade geschoben, ein array mit einem Wert, mit lastIndexOf bleibt wahrscheinlich die beste Lösung, aber wenn du die Reise durch die große arrays und das Ergebnis könnte überall sein, könnte dies eine solide Lösung, um die Dinge schneller.

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

Performance-test

http://jsperf.com/bidirectionalindexof

Als test habe ich erstellt ein array mit 100 Einträgen.

Drei Abfragen: am Anfang, in der Mitte & am Ende des Arrays.

Ich hoffe, dass Sie auch dies interessant finden und testen Sie die Leistung.

Hinweis: Wie Sie sehen können, die ich leicht modifiziert die contains Funktion zu reflektieren, die indexOf - & lastIndexOf Ausgabe (also im Grunde true mit der index und false mit -1). Das sollte nicht Schaden.

Die array-Prototyp-Variante

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

Kann die Funktion auch problemlos geändert werden, um true oder false zurückgeben oder sogar das Objekt, string oder was auch immer es ist.

Und hier ist die while Variante:

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

Wie ist das möglich?

Ich denke, dass die einfache Rechnung, um die reflektierte index in einem array ist so simpel, dass es zwei mal schneller als eine aktuelle loop iteration.

Hier ist ein komplexeres Beispiel, drei Prüfungen pro iteration, dies ist aber nur möglich mit einer längeren Berechnung, die bewirkt, dass die Verlangsamung der code.

http://jsperf.com/bidirectionalindexof/2

InformationsquelleAutor cocco

Checken Sie immer wieder auf die Existenz eines Objekts in einem array sollte man vielleicht schauen Sie in

1. Halten das array sortiert zu allen Zeiten durch machen insertion sort in das array (legen Sie neue Objekte an der richtigen Stelle)
2. Machen aktualisieren Objekte entfernen+sortiert insert-operation und
3. Verwenden binäre Suche lookup in Ihrem contains(a, obj).

InformationsquelleAutor Ztyx

Verwenden wir dieses snippet funktioniert mit Objekten, arrays, strings):

/*
 * @function
 * @name Object.prototype.inArray
 * @description Extend Object prototype within inArray function
 *
 * @param {mix}    needle       - Search-able needle
 * @param {bool}   searchInKey  - Search needle in keys?
 *
 */
Object.defineProperty(Object.prototype, 'inArray',{
    value: function(needle, searchInKey){

        var object = this;

        if( Object.prototype.toString.call(needle) === '[object Object]' || 
            Object.prototype.toString.call(needle) === '[object Array]'){
            needle = JSON.stringify(needle);
        }

        return Object.keys(object).some(function(key){

            var value = object[key];

            if( Object.prototype.toString.call(value) === '[object Object]' || 
                Object.prototype.toString.call(value) === '[object Array]'){
                value = JSON.stringify(value);
            }

            if(searchInKey){
                if(value === needle || key === needle){
                return true;
                }
            }else{
                if(value === needle){
                    return true;
                }
            }
        });
    },
    writable: true,
    configurable: true,
    enumerable: false
});

Verwendung:

var a = {one: "first", two: "second", foo: {three: "third"}};
a.inArray("first");          //true
a.inArray("foo");            //false
a.inArray("foo", true);      //true - search by keys
a.inArray({three: "third"}); //true

var b = ["one", "two", "three", "four", {foo: 'val'}];
b.inArray("one");         //true
b.inArray('foo');         //false
b.inArray({foo: 'val'})   //true
b.inArray("{foo: 'val'}") //false

var c = "String";
c.inArray("S");        //true
c.inArray("s");        //false
c.inArray("2", true);  //true
c.inArray("20", true); //false

InformationsquelleAutor dr.dimitru

Lösung, die funktioniert in allen modernen Browsern:

function contains(arr, obj) {
  const stringifiedObj = JSON.stringify(obj); //Cache our object to not call `JSON.stringify` on every iteration
  return arr.some(item => JSON.stringify(item) === stringifiedObj);
}

Verwendung:

contains([{a: 1}, {a: 2}], {a: 1}); //true

IE6+ Lösung:

function contains(arr, obj) {
  var stringifiedObj = JSON.stringify(obj)
  return arr.some(function (item) {
    return JSON.stringify(item) === stringifiedObj;
  });
}

//.some polyfill, not needed for IE9+
if (!('some' in Array.prototype)) {
  Array.prototype.some = function (tester, that /*opt*/) {
    for (var i = 0, n = this.length; i < n; i++) {
      if (i in this && tester.call(that, this[i], i, this)) return true;
    } return false;
  };
}

Verwendung:

contains([{a: 1}, {a: 2}], {a: 1}); //true

Warum JSON.stringify?

Array.indexOf und Array.includes (wie auch die meisten der Antworten hier) nur Vergleich von Referenz und nicht als Wert.

[{a: 1}, {a: 2}].includes({a: 1});
//false, because {a: 1} is a new object

Bonus

Nicht optimierten ES6 one-liner:

[{a: 1}, {a: 2}].some(item => JSON.stringify(item) === JSON.stringify({a: 1));
//true

Hinweis:
Vergleich von Objekten von Wert wird besser funktionieren, wenn die Tasten in der gleichen Reihenfolge, so sicher zu sein, könnten Sie die Sortierung der keys erst mit einem Paket wie diesem: https://www.npmjs.com/package/sort-keys

Aktualisiert die contains Funktion mit einem perf-Optimierung. Dank itinance für den Hinweis it out.

InformationsquelleAutor Igor Barbashin

ECMAScript-6 hat einen eleganten Vorschlag zu finden.

Die find-Methode führt die callback-Funktion einmal für jedes element
vorhanden im array, bis er eine findet, wo callback gibt ein true
Wert. Wenn ein solches element gefunden wird, finden sofort wieder den Wert
von diesem element. Ansonsten finden gibt Sie undefined zurück. Rückruf
nur aufgerufen, für die Indizes des Arrays die Werte zugewiesen; es
wird nicht aufgerufen, für Indizes, die gelöscht wurden oder die noch nie
wurden Werte zugewiesen.

Hier ist die MDN-Dokumentation.

Die suchen-Funktionen wie das funktioniert.

function isPrime(element, index, array) {
    var start = 2;
    while (start <= Math.sqrt(element)) {
        if (element % start++ < 1) return false;
    }
    return (element > 1);
}

console.log( [4, 6, 8, 12].find(isPrime) ); //Undefined, not found
console.log( [4, 5, 8, 12].find(isPrime) ); //5

Können Sie dies in ECMAScript 5 und unten von Definition der Funktion.

if (!Array.prototype.find) {
  Object.defineProperty(Array.prototype, 'find', {
    enumerable: false,
    configurable: true,
    writable: true,
    value: function(predicate) {
      if (this == null) {
        throw new TypeError('Array.prototype.find called on null or undefined');
      }
      if (typeof predicate !== 'function') {
        throw new TypeError('predicate must be a function');
      }
      var list = Object(this);
      var length = list.length >>> 0;
      var thisArg = arguments[1];
      var value;

      for (var i = 0; i < length; i++) {
        if (i in list) {
          value = list[i];
          if (predicate.call(thisArg, value, i, list)) {
            return value;
          }
        }
      }
      return undefined;
    }
  });
}

InformationsquelleAutor Pradeep Mahdevu

Hier ist, wie Prototyp funktioniert es:

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

Siehe auch hier, wie Sie es hook up.

InformationsquelleAutor Ken

Verwenden:

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

Ich weiß, es ist nicht der beste Weg zu gehen, aber da gibt es keine native IComparable Weg, um die Interaktion zwischen Objekten, ich denke, das ist so nah wie Sie bekommen können, vergleichen Sie zwei Elemente in einem array. Auch die Ausweitung Array-Objekt kann nicht eine kluge Sache zu tun, aber manchmal ist es OK (wenn Sie sich dessen bewusst sind und die trade-off).

InformationsquelleAutor Carlos A

Können Sie auch diesen trick verwenden:

var arrayContains = function(object) {
  return (serverList.filter(function(currentObject) {
    if (currentObject === object) {
      return currentObject
    }
    else {
      return false;
    }
  }).length > 0) ? true : false
}

InformationsquelleAutor user2724028