Vier Methoden zur Verwendung von JS zur Bestimmung von Datentypen

Vorwort

Die Datentypbeurteilung in JavaScript ist eigentlich ein sehr grundlegendes Problem in JavaScript, es kommt jedoch sowohl beim täglichen Programmieren als auch bei Interviews sehr häufig vor.

In der ECMAScript-Spezifikation sind insgesamt 7 Datentypen definiert, die in zwei Kategorien unterteilt sind: Basistypen und Referenztypen, wie unten gezeigt:

Grundtypen: String, Zahl, Boolean, Symbol, Undefiniert, Null

Referenztyp: Objekt

Basistypen werden auch einfache Typen genannt. Da sie einen festen Speicherplatz belegen und einfache Datensegmente sind, werden sie im Stapel gespeichert, um die Geschwindigkeit der Variablenabfrage zu erhöhen, d. h. des Zugriffs nach Wert.

Referenztypen werden auch komplexe Typen genannt. Da sich die Größe ihrer Werte ändert, können sie nicht im Stapel gespeichert werden, da dies sonst die Abfragegeschwindigkeit der Variablen verlangsamt. Daher werden ihre Werte im Heap gespeichert, und der in der Variablen gespeicherte Wert ist ein Zeiger auf den Speicher, in dem das Objekt gespeichert ist, d. h. der Zugriff erfolgt über die Adresse. Zu den Referenztypen zählen neben Objekten auch Funktionen, Arrays, RegExp, Datum usw.

Da ECMAScript lose typisiert ist, muss es eine Möglichkeit geben, den Datentyp einer bestimmten Variablen zu erkennen. Auch JavaScript bietet für dieses Problem verschiedene Methoden, doch leider führen unterschiedliche Methoden zu unterschiedlichen Ergebnissen.

Im Folgenden werden vier häufig verwendete Methoden vorgestellt und die bei jeder Methode vorhandenen Probleme kurz analysiert.

1. Art von

typeof ist ein Operator, der auf seiner rechten Seite einen unären Ausdruck annimmt und den Datentyp dieses Ausdrucks zurückgibt. Das zurückgegebene Ergebnis wird in Form einer Zeichenfolge dieses Typs (alles Kleinbuchstaben) ausgedrückt, einschließlich der folgenden 7 Typen: Zahl, Boolescher Wert, Symbol, Zeichenfolge, Objekt, undefiniert, Funktion usw.

typeof''; // string ist gültig typeof1; // number ist gültig typeofSymbol(); // symbol ist gültig typeoftrue; //boolean ist gültig typeofundefined; //undefined ist gültig typeofnull; //object ist ungültig typeof[]; //object ist ungültig typeofnewFunction(); // function ist gültig typeofnewDate(); //object ist ungültig typeofnewRegExp(); //object ist ungültig

Manchmal gibt der Typeof-Operator verwirrende, aber technisch korrekte Werte zurück:

• Für Basistypen, außer Null, können korrekte Ergebnisse zurückgegeben werden.
• Bei Referenztypen, außer bei Funktionen, wird immer der Objekttyp zurückgegeben.
• Für null wird der Objekttyp zurückgegeben.
• Gibt für die Funktion den Funktionstyp zurück.
  

Unter ihnen hat Null seinen eigenen Datentyp Null, und Arrays, Daten und reguläre Ausdrücke in Referenztypen haben auch ihre eigenen spezifischen Typen. Wenn typeof diese Typen verarbeitet, gibt es nur den Objekttyp am Anfang seiner Prototypkette zurück, was korrekt ist, aber nicht das gewünschte Ergebnis ist.

2. Instanz von

Mit Instanceof wird ermittelt, ob A eine Instanz von B ist. Der Ausdruck lautet: Eine Instanz von B. Wenn A eine Instanz von B ist, wird „true“ zurückgegeben, andernfalls „false“. Es ist wichtig zu beachten, dass instanceof den Prototyp erkennt. Wir verwenden einen Pseudocode, um seinen internen Ausführungsprozess zu simulieren:

Instanz von (A,B) = {
    varL = A.__proto__;
    varR = B.Prototyp;
    wenn(L === R) {
        // Die interne Eigenschaft von A __proto__ zeigt auf das Prototypobjekt von B returntrue;
    }
    Rückgabefalse;
}

Aus dem obigen Prozess können wir erkennen, dass A als Instanz von B betrachtet wird, wenn A's __proto__ auf B's ​​Prototyp zeigt. Sehen wir uns noch ein paar weitere Beispiele an:

[] Instanz von Array; // wahr
{} Instanz von Objekt; // wahr
newDate() Instanz von Date; // wahr
 
Funktion Person(){};
newPerson() Instanz von Person;
 
[] Instanz von Objekt; // wahr
newDate() Instanz von Objekt; // wahr
newPerson-Instanz von Objekt; // wahr

Wir haben festgestellt, dass instanceof zwar feststellen kann, dass [] eine Instanz von Array ist, aber gleichzeitig denkt, dass [] auch eine Instanz von Object ist. Warum?

Lassen Sie uns die Beziehung zwischen [], Array und Objekt analysieren:

Anhand von instanceof können wir erkennen, dass [].__proto__ auf Array.prototype zeigt und Array.prototype.__proto__ auf Object.prototype. Schließlich zeigt Object.prototype.__proto__ auf null und markiert damit das Ende der Prototypenkette. Daher bilden [], Array und Object intern eine Prototypenkette:

Aus der Prototypenkette können wir ersehen, dass __proto__ von [] direkt auf Array.prototype und indirekt auf Object.prototype verweist. Gemäß der Beurteilungsregel von instanceof ist [] also eine Instanz von Object. Analog dazu bilden auch ähnliche „new Date()“ und „new Person()“ eine entsprechende Prototypenkette. Daher kann instanceof nur verwendet werden, um zu bestimmen, ob sich zwei Objekte in einer Instanzbeziehung befinden, kann jedoch nicht den spezifischen Typ einer Objektinstanz bestimmen.

Das Problem mit dem Operator „instanceof“ besteht darin, dass er davon ausgeht, dass nur ein globaler Ausführungskontext existiert. Wenn eine Webseite mehrere Frames enthält, gibt es tatsächlich mehr als zwei unterschiedliche globale Ausführungsumgebungen und somit mehr als zwei unterschiedliche Versionen des Konstruktors. Wenn Sie ein Array von einem Framework an ein anderes übergeben, verfügt das übergebene Array über einen anderen Konstruktor als das Array, das nativ im zweiten Framework erstellt wurde.

variframe = document.createElement('iframe');
Dokument.body.appendChild(iframe);
xArray = Fenster.Frames[0].Array;
vararr = neuesxArray(1,2,3); // [1,2,3]
arr Instanz von Array; // falsch

Um dieses Array-Problem zu lösen, stellt ES5 die Methode Array.isArray() bereit. Mit dieser Methode wird bestätigt, ob ein Objekt selbst vom Typ Array ist, unabhängig von der Umgebung, in der das Objekt erstellt wird.

wenn(Array.isArray(Wert)){
   //Führen Sie eine Operation am Array aus}

Array.isArray() erkennt im Wesentlichen den [[Class]]-Wert eines Objekts. [[Class]] ist eine interne Eigenschaft eines Objekts, die die Typinformationen des Objekts enthält. Ihr Format ist [Objekt Xxx], wobei Xxx der entsprechende spezifische Typ ist. Bei Arrays ist der Wert von [[Klasse]] [Objekt-Array].

3. Konstruktor

Wenn eine Funktion F definiert wird, fügt die JS-Engine einen Prototyp zu F hinzu, fügt dann eine Konstruktoreigenschaft zum Prototyp hinzu und lässt ihn auf eine Referenz auf F zeigen. Wie unten dargestellt:

Bei der Ausführung von var f = new F() wird F als Konstruktor betrachtet und f ist ein Instanzobjekt von F. Zu diesem Zeitpunkt wird der Konstruktor des F-Prototyps an f übergeben, also f.constructor == F

Es ist ersichtlich, dass F den Konstruktor des Prototypobjekts verwendet, um auf sich selbst zu verweisen. Wenn F als Konstruktor zum Erstellen eines Objekts verwendet wird, wird der Konstruktor des Prototyps an das neu erstellte Objekt vererbt. Aus der Perspektive der Prototypkette ist der Konstruktor F der Typ des neuen Objekts. Der Sinn dieser Vorgehensweise besteht darin, dass neue Objekte nach ihrer Entstehung über nachverfolgbare Datentypen verfügen.

Ebenso werden die integrierten Objekte von JavaScript intern folgendermaßen konstruiert:

Details:

1. Null und undefined sind ungültige Objekte, daher gibt es keinen Konstruktor. Diese beiden Datentypen müssen auf andere Weise beurteilt werden.

2. Der Funktionskonstruktor ist instabil. Dies spiegelt sich hauptsächlich in benutzerdefinierten Objekten wider. Wenn der Entwickler den Prototyp neu schreibt, geht die ursprüngliche Konstruktorreferenz verloren und der Konstruktor wird standardmäßig auf „Object“ gesetzt.

Warum wurde es zu „Object“?

Da der Prototyp einem { } neu zugewiesen wird, was der Literalwert von new Object() ist, übergibt new Object() den Konstruktor des Objekt-Prototyps an { }, was Object selbst ist.

Um die Entwicklung zu standardisieren, ist es daher im Allgemeinen erforderlich, beim Neuschreiben des Objektprototyps den Konstruktor neu zuzuweisen, um sicherzustellen, dass der Typ der Objektinstanz nicht manipuliert wird.

4. toString

toString() ist die Prototypmethode von Object. Wenn diese Methode aufgerufen wird, gibt sie standardmäßig die [[Klasse]] des aktuellen Objekts zurück. Dies ist eine interne Eigenschaft mit dem Format [Objekt Xxx], wobei Xxx der Typ des Objekts ist.

Bei Object-Objekten gibt ein einfacher Aufruf von toString() [object Object] zurück. Für andere Objekte müssen sie über call/apply aufgerufen werden, um die richtigen Typinformationen zurückzugeben.

Object.prototype.toString.call('') ; // [Objekt String]
Object.prototype.toString.call(1); // [Objektnummer]
Object.prototype.toString.call(true) ; // [Objekt Boolean]
Object.prototype.toString.call(Symbol()); //[Objekt Symbol]
Object.prototype.toString.call(undefined) ; // [Objekt undefiniert]
Object.prototype.toString.call(null) ; // [Objekt Null]
Object.prototype.toString.call(newFunction()) ; // [Objektfunktion]
Object.prototype.toString.call(newDate()) ; // [Objekt Datum]
Object.prototype.toString.call([]) ; // [Objekt-Array]
Object.prototype.toString.call(newRegExp()) ; // [Objekt RegExp]
Object.prototype.toString.call(newError()) ; // [Objektfehler]
Object.prototype.toString.call(Dokument) ; // [Objekt HTMLDocument]
Object.prototype.toString.call(window) ; //[object global] window ist eine Referenz auf das globale Objekt global

Zusammenfassen

Dies ist das Ende dieses Artikels über die Verwendung von JS zur Bestimmung von Datentypen. Weitere relevante Inhalte zur JS-Datentypbestimmung finden Sie in den vorherigen Artikeln von 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, dass jeder 123WORDPRESS.COM in Zukunft unterstützen wird!