Zusammenfassung verschiedener Methoden für JavaScript um festzustellen ob es sich um ein Array handelt

Vorwort

Bei unserer täglichen Entwicklung müssen wir häufig den Typ eines Wertes bestimmen. Heute fassen wir einige gängige JavaScript-Methoden zusammen, mit denen festgestellt werden kann, ob es sich um ein Array handelt.

Array.istArray

Array.isArray() ist eine neue Methode, die in ES5 hinzugefügt wurde und mit der ermittelt wird, ob der übergebene Wert ein Array ist. Wenn es ein Array ist, wird true zurückgegeben, andernfalls false.

sei arr = [];
console.log(Array.isArray(arr)); // wahr

Die folgenden Funktionsaufrufe geben alle „true“ zurück:

Array.isArray([]);
Array.istArray([1]);
Array.isArray(neues Array());
Array.isArray(neues Array("a", "b", "c", "d"));

Zu beachten ist, dass Array.prototype tatsächlich auch ein Array ist.

Array.isArray(Array.prototype); // wahr

Die folgenden Funktionsaufrufe geben alle „false“ zurück:

Array.isArray();
Array.isArray({});
Array.isArray(null);
Array.isArray(undefiniert);
Array.istArray(17);
Array.isArray('Array');
Array.isArray(true);
Array.isArray(false);
Array.isArray(neues Uint8Array(32))
Array.isArray({ __proto__: Array.prototype });

Die Kompatibilität ist wie folgt dargestellt:

Wie Sie sehen, unterstützen alle neuen Versionen der gängigen Browser diese Methode und können bedenkenlos verwendet werden.

Konstruktor

Jede Instanz von Object verfügt über einen Konstruktor, der zum Speichern der Funktion verwendet wird, die zum Erstellen des aktuellen Objekts verwendet wird.

sei arr = [];
konsole.log(arr.constructor === Array); // wahr

Es ist zu beachten, dass der Konstruktor möglicherweise geändert wird und das Beurteilungsergebnis möglicherweise nicht genau ist, zum Beispiel:

sei arr = [1, 2, 3];
arr.konstruktor = Funktion () { }
konsole.log(arr.constructor === Array); // falsch

Es wird im Allgemeinen nicht empfohlen, den Konstruktor zu verwenden, um festzustellen, ob es sich um ein Array handelt. Wir müssen nur wissen, dass es eine solche Methode gibt.

Instanz von

Der Operator „instanceof“ wird verwendet, um zu erkennen, ob die Prototype-Eigenschaft der Konstruktorfunktion in der Prototype-Kette eines Instanzobjekts vorkommt. Zum Beispiel:

// Definieren Sie die Konstruktorfunktion C() {}
Funktion D() {}

var o = neues C();

o Instanz von C; // wahr, weil Object.getPrototypeOf(o) === C.prototype

o instanceof D; // false, weil D.prototype nicht in der Prototypenkette von o ist o instanceof Object; // true, weil Object.prototype.isPrototypeOf(o) true zurückgibt
C.prototype instanceof Object; // true, wie oben

Um zu bestimmen, ob es sich um ein Array handelt, wird „Instanceof“ wie folgt verwendet:

sei arr = [];
console.log(arr Instanz von Array); // wahr

Bei der Verwendung von instanceof sind zwei Punkte zu beachten:

• Der Prototyp des Konstruktors und die Prototypenkette der Instanz können sich ändern, sodass das Beurteilungsergebnis möglicherweise nicht unverändert bleibt.
• Die Verwendung von „instanceof“ in einem Seitenskript mit einem Iframe kann zu falschen Ergebnissen führen, da das Iframe eine unabhängige globale Umgebung hat und unterschiedliche globale Umgebungen unterschiedliche globale Objekte und somit unterschiedliche integrierte Typkonstruktoren haben.

istPrototypVon

Mit isPrototypeOf() kann getestet werden, ob ein Objekt in der Prototypenkette eines anderen Objekts vorhanden ist. Die Verwendung ist wie folgt:

Funktion Foo() {}
Funktion Bar() {}
Funktion Baz() {}

Bar.prototype = Objekt.erstellen(Foo.prototype);
Baz.prototype = Objekt.erstellen(Bar.prototype);

var baz = neues Baz();

console.log(Baz.prototype.isPrototypeOf(baz)); // wahr
console.log(Bar.prototype.isPrototypeOf(baz)); // wahr
console.log(Foo.prototype.isPrototypeOf(baz)); // wahr
console.log(Object.prototype.isPrototypeOf(baz)); // wahr

Wenn Sie „isPrototypeOf“ verwenden möchten, um zu bestimmen, ob der eingehende Parameter ein Array ist, können Sie es wie folgt verwenden:

sei arr = [];
console.log(Array.prototype.isPrototypeOf(arr)); // wahr

Objekt.prototype.toString

Jedes Objekt verfügt über eine toString()-Methode, die automatisch aufgerufen wird, wenn das Objekt als Textwert dargestellt wird oder wenn auf ein Objekt auf eine Weise verwiesen wird, die einen String erwartet.

Standardmäßig wird die Methode toString() von jedem Object-Objekt geerbt. Wenn diese Methode in einem benutzerdefinierten Objekt nicht überschrieben wird, gibt toString() die Zeichenfolge „[Objekttyp]“ zurück, wobei Typ der Typ des Objekts ist.

Sie können toString() verwenden, um den Typ jedes Objekts abzurufen. Damit jedes Objekt über Object.prototype.toString() erkannt werden kann, muss es als Function.prototype.call() oder Function.prototype.apply() aufgerufen werden, wobei das zu prüfende Objekt als erstes Argument, genannt thisArg, übergeben wird. Die Verwendung ist wie folgt:

var toString = Objekt.prototype.toString;

toString.call(neues Datum); // [Objekt Datum]
toString.call(neuer String); // [Objekt String]
toString.call(Math); // [Objekt Mathe]

//Seit JavaScript 1.8.5
toString.call(undefined); // [Objekt undefiniert]
toString.call(null); // [Objekt Null]

Wenn Sie feststellen möchten, ob ein Objekt ein Array ist, können Sie es folgendermaßen verwenden:

sei arr = [];
console.log(Object.prototype.toString.call(arr) === "[Objekt-Array]"); // wahr

Die Kompatibilität ist wie folgt:

Art von

Wenn es um die Beurteilung von Typen geht, denken viele Leute möglicherweise an die typeof-Methode. Lassen Sie uns hier den Inhalt im Zusammenhang mit typeof überprüfen.

Der Typeof-Operator gibt eine Zeichenfolge zurück, die den Typ seines nicht ausgewerteten Operanden angibt.

console.log(Typ von 42); // "Zahl"
console.log(Typ von 'Blubber'); // "Zeichenfolge"
console.log(Typ von true); // "Boolesch"
console.log(Typ der nicht deklarierten Variable); // "nicht definiert"

Die möglichen Rückgabewerte von typeof sind wie folgt:

Wie aus der obigen Abbildung ersichtlich ist, gehören Array-Objekte zu „jedem anderen Objekt“, sodass der Typ des Rückgabewerts von Array-Objekten „Objekt“ ist:

sei arr = [];
console.log(Typ von arr); // "Objekt"

Daher sollten wir versuchen, die Verwendung von typeof zu vermeiden.

Zusammenfassen

Oben sind mehrere Möglichkeiten aufgeführt, um zu bestimmen, ob ein Wert ein Array ist. Natürlich sind einige davon nützlich und andere nicht, aber egal, es ist immer gut zu wissen, dass es so etwas gibt. Um es zusammenzufassen:

• Die beste Methode ist Array.isArray, sie wird jedoch von IE8 und darunter nicht unterstützt.
• Wenn Kompatibilität ein Problem darstellt, können Sie Object.prototype.toString verwenden.

Dies ist das Ende dieses Artikels darüber, wie man mithilfe von JavaScript feststellt, ob etwas ein Array ist. Weitere Informationen dazu, wie man mithilfe von JavaScript feststellt, ob etwas ein Array ist, finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen!