Vier Methoden zur Datentypbeurteilung in JS

Dieser Artikel fasst vier Beurteilungsmethoden zusammen:

1. Art von

typeof ist ein Operator, der auf zwei Arten verwendet werden kann ：(1)typeof (Ausdruck); (2)typeof Variablenname; der Rückgabewert ist ein String, der den Datentyp der Variable beschreibt; er kann also verwendet werden, um die sieben Typen number , string , object , boolean , function , undefined und symbol Der jeweils zurückgegebene Inhalt ist in der folgenden Tabelle dargestellt:

// Zeichenfolge console.log(typeof('lili')); // Zeichenfolge 
// Nummer console.log(typeof(1)); // Nummer 
// Boolescher Wert console.log(typeof(true)); // Boolescher Wert 
// undefiniert 
console.log(Typ von (nicht definiert)); // nicht definiert 
// Objekt console.log(typeof({})); // Objekt 
// Array console.log(typeof([])); // Objekt 
// null 
console.log(Typ von(null)); // Objekt 
// Funktion console.log(typeof(() => {})); // Funktion 
// Symbolwert console.log(typeof(Symbol())); // Symbol 

2. Instanz von

instanceof wird verwendet, um zu erkennen, ob prototype Eigenschaft des Konstruktors in der Prototypenkette eines Instanzobjekts vorkommt. Der Rückgabewert ist ein Boolescher Wert, der angibt, ob eine Variable zu einer Instanz eines Objekts gehört. Die Syntax lautet wie folgt:

Objektinstanz des Konstruktors 

Konstanten arr = [1, 2]; 
// Überprüfen Sie, ob sich der Prototyp des Objekts in der Prototypenkette des Arrays befindet console.log(arr instanceof Object); // true 
// Prototyp des Arrays arr const proto1 = Object.getPrototypeOf(arr); 
konsole.log(proto1); // [] 
// Der Prototyp des Prototyps des Arrays arr const proto2 = Object.getPrototypeOf(proto1); 
konsole.log(proto2); // [] 
//Prototyp des Objekts 
konsole.log(Objekt.prototyp); 
// Überprüfen Sie, ob der Prototyp von arr dem Prototyp von Object entspricht console.log(proto1 === Object.prototype); // false 
// Überprüfen Sie, ob der Prototyp des Prototyps von arr dem Prototyp des Objekts entspricht console.log(proto2 === Object.prototype); // true 
 

3. Konstruktor

Diese Beurteilungsmethode betrifft tatsächlich die Beziehung zwischen Prototypen, Konstruktoren und Instanzen. Eine ausführlichere Erklärung wird später gegeben. Im Folgenden müssen Sie nur kurz die Beziehung zwischen diesen drei verstehen.

Beim Definieren einer Funktion (Konstruktor) fügt die JS-Engine dieser einen prototype hinzu. Der Prototyp verfügt über eine entsprechende constructor Eigenschaft, die auf den Konstruktor verweist, sodass sich Prototyp und Konstruktor kennen. Wenn der Konstruktor instantiiert wird, wird eine entsprechende Instanz generiert. Die Instanz kann auf constructor Konstruktoreigenschaft des entsprechenden Prototyps zugreifen, sodass die Instanz verstehen kann, wer ihn generiert hat, und somit den Datentyp des neuen Objekts nach seiner Generierung verstehen kann.

konstanter Wert1 = 1; 
console.log(val1.constructor); // [Funktion: Zahl] 
const val2 = "abc"; 
console.log(val2.constructor); // [Funktion: String] 
Konstantenwert3 = wahr; 
console.log(val3.constructor); // [Funktion: Boolean] 

Obwohl diese Methode den Datentyp bestimmen kann, hat sie zwei Nachteile:

• null und undefined sind ungültige Objekte, daher gibt es keinen constructor . Diese beiden Datentypen müssen auf andere Weise beurteilt werden.
• constructor einer Funktion ist instabil. Dies spiegelt sich vor allem in benutzerdefinierten Objekten wider. Wenn der Entwickler prototype neu schreibt, geht die ursprüngliche constructor verloren und constructor wird standardmäßig auf Object

4. toString()

toString() ist die Prototypmethode von Object . Wenn diese Methode aufgerufen wird, wird standardmäßig [[Class]] des aktuellen Objekts zurückgegeben. Dies ist eine interne Eigenschaft mit dem Format [object Xxx] wobei Xxx der Typ des Objekts ist. Daher kann Object.prototype.toString() verwendet werden, um den Typ der Variablen genauer zu beurteilen.

Die von diesem Typ für verschiedene Variablentypen zurückgegebenen Ergebnisse lauten wie folgt:

Mit dieser Methode lässt sich leicht eine Typidentifikationsfunktion konstruieren. Der Code lautet wie folgt:

Funktionstyp (Ziel) { 
    const ret = Typ von (Ziel); 
    const Vorlage = { 
        "[Objekt-Array]": "Array",  
        "[Objekt Objekt]":"Objekt", 
        "[Objektnummer]":"Nummer - Objekt", 
        "[Objekt Boolean]":"Boolesch - Objekt", 
        "[Objekt String]":'Zeichenfolge-Objekt' 
    } 
    wenn(Ziel === null) { 
        gibt „null“ zurück; 
    } 
    sonst wenn(ret == "Objekt"){ 
        const str = Object.prototype.toString.call(Ziel); 
        Vorlage zurückgeben[str]; 
    } 
    anders{ 
        Rückkehr ret; 
    } 
} 

console.log(Typ({})); // Objekt 
console.log(Typ(123)); // Nummer 
console.log(Typ('123')); // Zeichenfolge 

Damit ist dieser Artikel über die vier Datentyp-Beurteilungsmethoden in JS abgeschlossen. Weitere Informationen zu Datentyp-Beurteilungsmethoden in JS 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!