Beispiele für korrekte Beurteilungsmethoden für Datentypen in JS

Vorwort

Javascript ist eine dynamisch typisierte Sprache. Von der Deklaration bis zur endgültigen Verwendung kann eine Variable viele Funktionen durchlaufen und der Datentyp kann sich auch ändern. Daher ist es besonders wichtig, den Datentyp einer Variablen zu beurteilen.

Kann typeof den Typ korrekt bestimmen?

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.

Aus historischen Gründen ist typeof null bei der Beurteilung primitiver Typen gleich object. Darüber hinaus werden Objekte und Arrays in Objekte umgewandelt. Hier sind einige Beispiele:

    Typ von 1 // 'Zahl'
    Typ von "1" // 'Zeichenfolge'
    Typ von null // 'Objekt'
    Typ von undefiniert // 'undefiniert'
    
    Typ von [] // 'Objekt'
    Typ von {} // 'Objekt'
    Typ der Funktion () {} // 'Funktion'

Wir können also feststellen, dass typeof grundlegende Datentypen bestimmen kann, es aber schwierig ist, andere komplexe Datentypen als Funktionen zu bestimmen. Daher können wir die zweite Methode verwenden, die normalerweise zum Bestimmen komplexer Datentypen verwendet wird und auch zum Bestimmen grundlegender Datentypen verwendet werden kann.

Für den Rückgabewert eines Objekts gibt es drei Fälle:

• Der Wert ist null
• Wert ist Objekt
• Wert ist Array

Für null können wir direkt === verwenden, um eine Beurteilung zu treffen, aber was ist mit Arrays und Objekten? Keine Sorge, lass uns weitermachen.

Kann instanceof den Typ korrekt bestimmen?

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“.

Instanceof wird anhand der Prototypenkette beurteilt, bei Objekten wird Array jedoch auch in Object konvertiert und es kann nicht zwischen den Basistypen String und Boolean unterschieden werden. Sie können den Inhalt, den Sie beurteilen möchten, links und den Typ rechts platzieren, um eine JS-Typbeurteilung durchzuführen. Es kann nur zur Beurteilung komplexer Datentypen verwendet werden, da instanceof verwendet wird, um festzustellen, ob die Prototypeigenschaft der Konstruktorfunktion (rechts) in der Prototypkette eines bestimmten Instanzobjekts (links) erscheint. Zum Beispiel:

    Funktion Func() {}
    const func = neue Func()
    console.log(Funktion Instanz von Func) // true
    
    const obj = {}
    const arr = []
    obj Instanz von Objekt // true
    arr Instanz des Objekts // true
    arr Instanz von Array // wahr
    
    const str = "abc"
    const str2 = neuer String("abc")
    str-Instanz von String // false
    str2 Instanz von String // true

Die alleinige Verwendung von instanceof scheint nicht zu funktionieren, aber wir sind zu dem Schluss gekommen, dass typeof nicht zwischen Arrays und Objekten unterscheiden kann. Kombinieren wir also instanceof, um eine vollständige Beurteilungslogik zu schreiben.

    Funktion meinTypvon(Daten) {
        const type = Datentyp
        wenn (Daten === null) {
            returniere 'null'
        }
        wenn (Typ !== 'Objekt') {
            Rückgabetyp
        }
        if (Dateninstanz des Arrays) {
            gibt 'Array' zurück
        }
        gib 'Objekt' zurück
    }

Objekt.prototype.toString.call()

Oben haben wir eine Version der Typbeurteilung durch typeof und instanceof implementiert. Gibt es also andere Kanäle, um unseren Code prägnanter zu gestalten? Die Antwort ist, Object.prototype.toString.call() zu verwenden.

Jedes Objekt hat eine toString()-Methode, die automatisch aufgerufen wird, wenn Sie das Objekt als Textwert darstellen oder auf eine Weise auf das Objekt verweisen möchten, die einen String erwartet. Standardmäßig erbt jedes von Object abgeleitete Objekt die Methode toString(). Wenn diese Methode in einem benutzerdefinierten Objekt nicht überschrieben wird, gibt toString() zurück

    Object.prototype.toString.call(new Date()) // [Objekt Datum]
    Object.prototype.toString.call("1") // [Objekt String]
    Object.prototype.toString.call(1) // [Objektnummer]
    Object.prototype.toString.call(undefined) // [Objekt undefiniert]
    Object.prototype.toString.call(null) // [Objekt Null]

Basierend auf den oben genannten Wissenspunkten können wir die folgende allgemeine Methode zur Typbeurteilung zusammenfassen:

    Funktion meinTypvon(Daten) {
        var toString = Objekt.prototype.toString;
        var dataType = Dateninstanz des Elements ? "element" : toString.call(data).replace(/\[object\s(.+)\]/, "$1").toLowerCase()
        Datentyp zurückgeben
    };

    myTypeof("a") // Zeichenfolge
    myTypeof(1) // Zahl
    myTypeof(Fenster) // Fenster
    meinTypeof(document.querySelector("h1")) // Element

Konstruktor

Die Beurteilungsmethode des Konstruktors ähnelt der von instanceof, aber die Konstruktorerkennung von Object unterscheidet sich von instanceof. Der Konstruktor kann auch die Erkennung grundlegender Datentypen verarbeiten, nicht nur von Objekttypen.

Beachten:

1.null und undefined haben keinen Konstruktor;

2. Verwenden Sie (), wenn Sie Zahlen beurteilen, z. B. (123).constructor. Wenn Sie 123.constructor schreiben, wird eine Fehlermeldung angezeigt.

3. Der Konstruktor schlägt fehl, wenn die Klasse erbt, da das Objekt überschrieben wird und das Erkennungsergebnis falsch ist

    Funktion A() {};
    Funktion B() {};
    A.Prototyp = neues B();
    konsole.log(A.constructor === B) // falsch

    var C = neues A();
    konsole.log(C.constructor === B) // wahr
    konsole.log(C.constructor === A) // falsch 

    C.Konstruktor = A;
    konsole.log(C.constructor === A); // wahr
    konsole.log(C.constructor === B); // falsch

Array.isArray()

Mit Array.isArray() wird ermittelt, ob der übergebene Wert ein Array ist. Gibt „true“ zurück, wenn das Objekt ein Array<String, String> ist, andernfalls „false“.

    Array.isArray([1, 2, 3]); // wahr
    Array.isArray({foo: 123}); // falsch
    Array.isArray("foobar"); // falsch
    Array.isArray(undefiniert); // falsch

Regelmäßiges Urteil

Wir können Objekte und Arrays in einen String konvertieren, sodass wir eine Formatbeurteilung vornehmen und den endgültigen Typ erhalten können.

    Funktion meinTypvon(Daten) {
        const str = JSON.stringify(Daten)
        wenn (/^{.*}$/.test(data)) {
            gib 'Objekt' zurück
        }
        wenn (/^\[.*\]$/.test(data)) {
            gibt 'Array' zurück
        }
    }

Zusammenfassen

Dies ist das Ende dieses Artikels über die richtige Methode zur Beurteilung des Datentyps in JS. Weitere relevante Inhalte zur Beurteilung des JS-Datentyps 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!

Dies ist das Ende dieses Artikels über die richtige Methode zur Beurteilung des Datentyps in JS. Weitere relevante Inhalte zur Beurteilung des JS-Datentyps 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!