So erkennen Sie, ob eine Variable ein Array ist

Was ist die beste de-facto standardmäßige browserübergreifende Methode, um festzustellen, ob eine Variable in JavaScript ein Array ist oder nicht?

Beim Durchsuchen des Webs gibt es eine Reihe verschiedener Vorschläge, von denen einige gut und einige ungültig sind.

Das Folgende ist beispielsweise ein grundlegender Ansatz:

function isArray(obj) {
    return (obj && obj.length);
}

Beachten Sie jedoch, was passiert, wenn das Array leer ist oder obj tatsächlich kein Array ist, sondern eine Längeneigenschaft usw. implementiert.

Welche Implementierung ist die beste, um tatsächlich zu arbeiten, browserübergreifend zu sein und dennoch effizient zu arbeiten?

Die Typprüfung von Objekten in JS erfolgt über instanceof, dh

obj instanceof Array

Dies funktioniert nicht, wenn das Objekt über Frame-Grenzen hinweg übergeben wird, da jeder Frame ein eigenes ArrayObjekt hat. Sie können dies umgehen, indem Sie die interne [[Klasse]] - Eigenschaft des Objekts überprüfen . Verwenden Sie dazu Object.prototype.toString()(dies funktioniert garantiert mit ECMA-262):

Object.prototype.toString.call(obj) === '[object Array]'

Beide Methoden funktionieren nur für tatsächliche Arrays und nicht für Array-ähnliche Objekte wie die argumentsObjekt- oder Knotenlisten. Da alle Array-ähnlichen Objekte eine numerische lengthEigenschaft haben müssen, würde ich Folgendes überprüfen:

typeof obj !== 'undefined' && obj !== null && typeof obj.length === 'number'

Bitte beachten Sie, dass Zeichenfolgen diese Prüfung bestehen, was zu Problemen führen kann, da der IE den Zugriff auf die Zeichen einer Zeichenfolge nach Index nicht zulässt. Daher möchten Sie möglicherweise zu ändern typeof obj !== 'undefined', typeof obj === 'object'um 'object'Grundelemente und Hostobjekte mit Typen auszuschließen, die sich von insgesamt unterscheiden. Dadurch werden weiterhin Zeichenfolgenobjekte passieren, die manuell ausgeschlossen werden müssten.

In den meisten Fällen möchten Sie tatsächlich wissen, ob Sie über numerische Indizes über das Objekt iterieren können. Daher ist es möglicherweise eine gute Idee, zu überprüfen, ob das Objekt 0stattdessen eine Eigenschaft mit dem Namen hat. Dies kann über eine der folgenden Überprüfungen erfolgen:

typeof obj[0] !== 'undefined' // false negative for `obj[0] = undefined`
obj.hasOwnProperty('0') // exclude array-likes with inherited entries
'0' in Object(obj) // include array-likes with inherited entries

Die Umwandlung in ein Objekt ist erforderlich, um für Array-ähnliche Grundelemente (dh Zeichenfolgen) ordnungsgemäß zu funktionieren.

Hier ist der Code für zuverlässige Überprüfungen von JS-Arrays:

function isArray(obj) {
    return Object.prototype.toString.call(obj) === '[object Array]';
}

und iterierbare (dh nicht leere) Array-ähnliche Objekte:

function isNonEmptyArrayLike(obj) {
    try { // don't bother with `typeof` - just access `length` and `catch`
        return obj.length > 0 && '0' in Object(obj);
    }
    catch(e) {
        return false;
    }
}

Mit der Einführung von ECMAScript 5th Edition können wir am sichersten testen, ob eine Variable ein Array ist: Array.isArray () :

Array.isArray([]); // true

Während die hier akzeptierte Antwort für die meisten Browser über Frames und Fenster hinweg funktioniert , gilt dies nicht für Internet Explorer 7 und niedriger , da ein Object.prototype.toStringAufruf eines Arrays aus einem anderen Fenster [object Object]nicht zurückgegeben wird [object Array]. IE 9 scheint ebenfalls auf dieses Verhalten zurückgegangen zu sein (siehe aktualisierte Korrektur unten).

Wenn Sie eine Lösung suchen, die in allen Browsern funktioniert, können Sie Folgendes verwenden:

(function () {
    var toString = Object.prototype.toString,
        strArray = Array.toString(),
        jscript  = /*@cc_on @_jscript_version @*/ +0;

    // jscript will be 0 for browsers other than IE
    if (!jscript) {
        Array.isArray = Array.isArray || function (obj) {
            return toString.call(obj) == "[object Array]";
        }
    }
    else {
        Array.isArray = function (obj) {
            return "constructor" in obj && String(obj.constructor) == strArray;
        }
    }
})();

Es ist nicht ganz unzerbrechlich, aber es würde nur von jemandem gebrochen, der sich bemüht, es zu brechen. Es umgeht die Probleme in IE7 und niedriger und IE9. Der Fehler ist in IE 10 PP2 weiterhin vorhanden , wurde jedoch möglicherweise vor der Veröffentlichung behoben.

PS, wenn Sie sich über die Lösung nicht sicher sind, empfehle ich Ihnen, sie nach Herzenslust zu testen und / oder den Blog-Beitrag zu lesen. Es gibt andere mögliche Lösungen, wenn Sie sich mit der bedingten Kompilierung nicht wohl fühlen.

Crockford hat zwei Antworten auf Seite 106 von "The Good Parts". Der erste überprüft den Konstruktor, gibt jedoch über verschiedene Frames oder Fenster hinweg falsche Negative aus. Hier ist der zweite:

if (my_value && typeof my_value === 'object' &&
        typeof my_value.length === 'number' &&
        !(my_value.propertyIsEnumerable('length')) {
    // my_value is truly an array!
}

Crockford weist darauf hin, dass diese Version das argumentsArray als Array identifiziert , obwohl es keine der Array-Methoden enthält.

Seine interessante Diskussion des Problems beginnt auf Seite 105.

Es gibt hier eine weitere interessante Diskussion (Post-Good Parts) , die diesen Vorschlag enthält:

var isArray = function (o) {
    return (o instanceof Array) ||
        (Object.prototype.toString.apply(o) === '[object Array]');
};

Bei all den Diskussionen möchte ich nie wissen, ob etwas ein Array ist oder nicht.

jQuery implementiert eine isArray-Funktion, die den besten Weg vorschlägt, dies zu tun

function isArray( obj ) {
    return toString.call(obj) === "[object Array]";
}

(Ausschnitt aus jQuery v1.3.2 - leicht angepasst, um außerhalb des Kontexts einen Sinn zu ergeben)

Diebstahl von Guru John Resig und jquery:

function isArray(array) {
    if ( toString.call(array) === "[object Array]") {
        return true;
    } else if ( typeof array.length === "number" ) {
        return true;
    }
    return false;
}

Was machen Sie mit dem Wert, wenn Sie sich für ein Array entschieden haben?

Wenn Sie beispielsweise die enthaltenen Werte auflisten möchten , wenn sie wie ein Array aussehen, ODER wenn es sich um ein Objekt handelt, das als Hash-Tabelle verwendet wird, erhält der folgende Code das, was Sie möchten (dieser Code stoppt, wenn die Schließfunktion etwas anderes zurückgibt als "undefiniert". Beachten Sie, dass es NICHT über COM-Container oder Aufzählungen iteriert; dies bleibt als Übung für den Leser):

function iteratei( o, closure )
{
    if( o != null && o.hasOwnProperty )
    {
        for( var ix in seq )
        {
            var ret = closure.call( this, ix, o[ix] );
            if( undefined !== ret )
                return ret;
        }
    }
    return undefined;
}

(Hinweis: "o! = Null" -Tests für null und undefiniert)

Anwendungsbeispiele:

// Find first element who's value equals "what" in an array
var b = iteratei( ["who", "what", "when" "where"],
    function( ix, v )
    {
        return v == "what" ? true : undefined;
    });

// Iterate over only this objects' properties, not the prototypes'
function iterateiOwnProperties( o, closure )
{
    return iteratei( o, function(ix,v)
    {
        if( o.hasOwnProperty(ix) )
        {
            return closure.call( this, ix, o[ix] );
        }
    })
}

Wenn Sie dies in CouchDB (SpiderMonkey) tun, verwenden Sie

Array.isArray(array)

wie array.constructor === Arrayoder array instanceof Arraynicht funktionieren. Die Verwendung array.toString() === "[object Array]"funktioniert, scheint aber im Vergleich ziemlich zwielichtig zu sein.

Wenn Sie browserübergreifend möchten, möchten Sie jQuery.isArray .

Auf w3school gibt es ein Beispiel, das durchaus Standard sein sollte.

Um zu überprüfen, ob eine Variable ein Array ist, verwenden sie etwas Ähnliches

function arrayCheck(obj) { 
    return obj && (obj.constructor==Array);
}

getestet auf Chrome, Firefox, Safari, ie7

Eine der am besten recherchierten und diskutierten Versionen dieser Funktion finden Sie auf der PHPJS-Website . Sie können auf Pakete verlinken oder direkt zur Funktion gehen . Ich empfehle die Site sehr für gut konstruierte Äquivalente von PHP-Funktionen in JavaScript.

Nicht genügend Referenz gleich Konstruktoren. Manchmal haben sie unterschiedliche Referenzen des Konstruktors. Also benutze ich String-Darstellungen von ihnen.

function isArray(o) {
    return o.constructor.toString() === [].constructor.toString();
}

Ersetzen Array.isArray(obj)durchobj.constructor==Array

Proben :

Array('44','55').constructor==Array return true (IE8 / Chrome)

'55'.constructor==Array return false (IE8 / Chrome)