JavaScript-Äquivalent zu PHPs in_array ()

Gibt es in JavaScript eine Möglichkeit, Werte aus einem Array zu vergleichen und festzustellen, ob sie sich in einem anderen Array befinden?

Ähnlich wie bei PHP in_array?

Nein, es hat keinen. Aus diesem Grund enthalten die meisten gängigen Bibliotheken eine in ihren Dienstprogrammpaketen. Schauen Sie sich jQuery InArray und Prototype Array.indexOf für Beispiele.

Die Implementierung von jQuery ist so einfach, wie Sie es vielleicht erwarten:

function inArray(needle, haystack) {
    var length = haystack.length;
    for(var i = 0; i < length; i++) {
        if(haystack[i] == needle) return true;
    }
    return false;
}

Wenn Sie mit einer vernünftigen Anzahl von Array-Elementen zu tun haben, reicht das oben Genannte aus.

EDIT : Whoops. Ich habe nicht einmal bemerkt, dass Sie sehen wollten, ob sich ein Array in einem anderen befindet. Laut der PHP-Dokumentation ist dies das erwartete Verhalten von PHPs in_array:

$a = array(array('p', 'h'), array('p', 'r'), 'o');

if (in_array(array('p', 'h'), $a)) {
    echo "'ph' was found\n";
}

if (in_array(array('f', 'i'), $a)) {
    echo "'fi' was found\n";
}

if (in_array('o', $a)) {
    echo "'o' was found\n";
}

// Output:
//  'ph' was found
//  'o' was found

Der von Chris und Alex gepostete Code folgt diesem Verhalten nicht. Alex's ist die offizielle Version von Prototypes indexOf und Chris's ähnelt eher PHPs array_intersect. Das macht was du willst:

function arrayCompare(a1, a2) {
    if (a1.length != a2.length) return false;
    var length = a2.length;
    for (var i = 0; i < length; i++) {
        if (a1[i] !== a2[i]) return false;
    }
    return true;
}

function inArray(needle, haystack) {
    var length = haystack.length;
    for(var i = 0; i < length; i++) {
        if(typeof haystack[i] == 'object') {
            if(arrayCompare(haystack[i], needle)) return true;
        } else {
            if(haystack[i] == needle) return true;
        }
    }
    return false;
}

Und das ist mein Test von oben drauf:

var a = [['p','h'],['p','r'],'o'];
if(inArray(['p','h'], a)) {
    alert('ph was found');
}
if(inArray(['f','i'], a)) {
    alert('fi was found');
}
if(inArray('o', a)) {
    alert('o was found');
}  
// Results:
//   alerts 'ph' was found
//   alerts 'o' was found

Beachten Sie, dass ich den Array-Prototyp absichtlich nicht erweitert habe, da dies im Allgemeinen eine schlechte Idee ist.

Es gibt jetzt Array.prototype.includes:

Die Methode include () bestimmt, ob ein Array ein bestimmtes Element enthält, und gibt je nach Bedarf true oder false zurück.

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

Syntax

arr.includes(searchElement)
arr.includes(searchElement, fromIndex)

Array.indexOfwurde in JavaScript 1.6 eingeführt, wird jedoch in älteren Browsern nicht unterstützt. Zum Glück haben die Jungs bei Mozilla die ganze harte Arbeit für Sie geleistet und Ihnen dies aus Kompatibilitätsgründen zur Verfügung gestellt:

if (!Array.prototype.indexOf)
{
  Array.prototype.indexOf = function(elt /*, from*/)
  {
    var len = this.length >>> 0;

    var from = Number(arguments[1]) || 0;
    from = (from < 0)
         ? Math.ceil(from)
         : Math.floor(from);
    if (from < 0)
      from += len;

    for (; from < len; from++)
    {
      if (from in this &&
          this[from] === elt)
        return from;
    }
    return -1;
  };
}

Es gibt sogar einige praktische Verwendungsausschnitte für Ihr Skriptvergnügen.

Wenn die Indizes nicht aufeinanderfolgend sind oder wenn die Indizes nicht aufeinanderfolgend sind, wird der Code in den anderen hier aufgeführten Lösungen unterbrochen. Eine Lösung, die etwas besser funktionieren würde, könnte sein:

function in_array(needle, haystack) {
    for(var i in haystack) {
        if(haystack[i] == needle) return true;
    }
    return false;
}

Und als Bonus ist hier das Äquivalent zu PHPs array_search (um den Schlüssel des Elements im Array zu finden:

function array_search(needle, haystack) {
    for(var i in haystack) {
        if(haystack[i] == needle) return i;
    }
    return false;
}

Es gibt ein Projekt namens Locutus , es implementiert PHP-Funktionen in Javascript und in_array () ist enthalten. Sie können es genau so verwenden, wie Sie es in PHP verwenden.

Anwendungsbeispiele:

in_array('van', myArray);

in_array(1, otherArray, true); // Forcing strict type

Sie können einfach die Funktion "Includes" verwenden, wie in dieser Lektion zu w3schools erläutert

es sieht aus wie

let myArray = ['Kevin', 'Bob', 'Stuart'];
if( myArray.includes('Kevin'))
console.log('Kevin is here');

var a = [1,2,3,4,5,6,7,8,9];

var isSixInArray = a.filter(function(item){return item==6}).length ? true : false;

var isSixInArray = a.indexOf(6)>=0;

Die jQuery-Lösung ist verfügbar. Überprüfen Sie die Dokumentation hier: http://api.jquery.com/jquery.inarray/

$.inArray( 10, [ 8, 9, 10, 11 ] );

Es gibt eine äquivalente Funktion:

includes()

Schauen Sie hier: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes

Wenn Sie nur überprüfen möchten, ob sich ein einzelner Wert in einem Array befindet, erledigt der Code von Paolo die Aufgabe. Wenn Sie überprüfen möchten, welche Werte beiden Arrays gemeinsam sind, möchten Sie Folgendes (mithilfe der inArray-Funktion von Paolo):

function arrayIntersect(a, b) {
    var intersection = [];

    for(var i = 0; i < a.length; i++) {
        if(inArray(b, a[i]))
            intersection.push(a[i]);
    }

    return intersection;
}

Dies gibt ein Array von Werten zurück, die sowohl in aals auch in enthalten sind b. (Mathematisch gesehen ist dies ein Schnittpunkt der beiden Arrays.)

EDIT: Siehe Paolos Edited - Code für die Lösung für Ihr Problem. :) :)

Wenn Sie alle verfügbaren PHP- Parameter benötigen , verwenden Sie diese:

function in_array(needle, haystack, argStrict) {
    var key = '', strict = !!argStrict;
    if (strict) {
        for (key in haystack) {
            if (haystack[key] === needle) {
                return true;
            }
        }
    }
    else {
        for (key in haystack) {
            if (haystack[key] == needle) {
                return true;
            }
        }
    }
    return false;
}

Fügen Sie diesen Code Ihrem Projekt hinzu und verwenden Sie die inArray-Methoden im Objektstil

if (!Array.prototype.inArray) {
    Array.prototype.inArray = function(element) {
        return this.indexOf(element) > -1;
    };
} 
//How it work
var array = ["one", "two", "three"];
//Return true
array.inArray("one");

Mit Dojo Toolkit würden Sie verwenden dojo.indexOf(). Die Dokumentation finden Sie unter dojo.indexOf und einige Beispiele unter Arrays Made Easy von Bryan Forbes.

haystack.find(value => value == needle)

Dabei ist Heuhaufen ein Array und Nadel ein Element im Array. Wenn das nicht gefundene Element undefiniert zurückgegeben wird, wird dasselbe Element zurückgegeben.

function in_array(what, where) {
    var a=false;
    for (var i=0; i<where.length; i++) {
        if(what == where[i]) {
            a=true;
            break;
        }
    }
    return a;
}

Ich habe hier auf SO eine großartige jQuery-Lösung gefunden .

var success = $.grep(array_a, function(v,i) {
    return $.inArray(v, array_b) !== -1;
}).length === array_a.length;

Ich wünschte, jemand würde ein Beispiel dafür in Unterstrich posten.

function in_array(needle, haystack){

    return haystack.indexOf(needle) !== -1;
}

Ein Äquivalent von in_arraywith underscoreist _.indexOf

Beispiele:

_.indexOf([3, 5, 8], 8); // returns 2, the index of 8 _.indexOf([3, 5, 8], 10); // returns -1, not found

Wenn Sie es in einer Klasse verwenden möchten und wenn Sie es vorziehen, dass es funktionsfähig ist (und in allen Browsern funktioniert):

inArray: function(needle, haystack)
{
    var result = false;

    for (var i in haystack) {
        if (haystack[i] === needle) {
            result = true;
            break;
        }
    }

    return result;
}

Hoffe es hilft jemandem :-)