JavaScript erkennt ursprüngliche Werte, Referenzwerte und Attribute

In JavaScript sehen wir häufig Code wie folgt: Ein Vergleich von Variablen mit NULL (diese Verwendung ist sehr problematisch), mit der festgestellt wird, ob eine Variable einen vernünftigen Wert erhält. Zum Beispiel:

 var controller = {prozess: function (items) {if (items!

In diesem Code erwartet die Process () -Methode offensichtlich ein Array, da wir die Elemente sehen, die Sort () und foreach () haben. Die Absicht dieses Code ist sehr offensichtlich: Wenn die Parameterelemente keine Gruppennummer sind, wird die nächste Operation gestoppt. Das Problem bei dieser Schreibmethode ist, dass der Vergleich mit Null Fehler nicht wirklich verhindern kann. Der Wert der Elemente kann 1, eine Zeichenfolge oder sogar jedes Objekt betragen. Diese Werte sind nicht gleich Null, was wiederum einen Fehler verursacht, wenn die Process () -Methode in Sort () ausgeführt wird.

Der Vergleich mit Null allein liefert nicht genügend Informationen, um festzustellen, ob die nachfolgende Codeausführung wirklich sicher ist. Glücklicherweise bietet uns JavaScript viele Möglichkeiten, den wahren Wert einer Variablen zu erkennen.

Originalwert erkennen

In JavaScript gibt es 5 primitive Typen (auch als einfache Datentypen bezeichnet): String, Nummer, Boolesche, undefinierte und Null. Wenn Sie möchten, dass ein Wert String, Nummer, Boolean oder undefiniert ist, besteht die beste Option darin, den Typtyp -Operator zu verwenden, der eine Zeichenfolge zurückgibt, die den Typ darstellt.

Für Zeichenfolgen gibt Typof "String" zurück.

Für Zahlen gibt TypoF "Nummer" zurück.

Für Boolesche gibt Typof "boolean" zurück.

Für undefinierte kehrt Typof "undefiniert" zurück.

Die grundlegende Syntax von TypeOF ist: Typof Variable, Sie können auch Typenof (Variable) verwenden, obwohl dies die legale JavaScript -Syntax ist, die Typen von Typen wie eine Funktion und nicht wie ein Bediener aussieht. In Anbetracht dessen empfehlen wir das Schreiben ohne Klammern.

Die Verwendung von Typen zum Nachweis dieser 4 primitiven Typen ist sehr sicher. Schauen wir uns die folgenden Beispiele an.

 // "String" if (typeof name === "String") {AnotherName = name.substring (3);} // "nummer" if (typeof count === "number") {updateCount (count);} // Erfassungs "boolean" if (typeof fought ===== "boolean" {{{{Message "(" {usection "{{{Message (" ({{Message! ". (typeof myapp === "undefined") {MyApp = {// Andere Code};}

Der Typeof -Operator ist insofern eindeutig, als er keinen Fehler bei der Verwendung mit einer nicht deklarierten Variablen meldet. Undefinierte Variablen und Variablen mit undefinierter Wert geben beide über TypOF "undefiniert" zurück.

Der letzte primitive Typ null wird über TypOF "Objekt" zurückgegeben, das seltsam aussieht und als schwerwiegender Fehler in der Standardspezifikation angesehen wird. Bei der Programmierung müssen Sie also verhindern, dass die Verwendung von Typof Null -Typen erfasst.

 console.log (typeof null); // "Objekt"

Der einfache Vergleich mit NULL enthält normalerweise nicht genügend Informationen, um festzustellen, ob der Werttyp legal ist, sodass NULL in der Erkennungserklärung im Allgemeinen nicht verwendet wird.

Aber es gibt eine Ausnahme, wenn der erwartete Wert wirklich null ist, können Sie direkt mit Null vergleichen. Zum Beispiel:

 // Wenn Sie NULL erkennen müssen, verwenden Sie diese Methode var element = document.getElementById ("my-div"); if (element! == null) {element.className = "gefunden";}

Wenn das DOM -Element nicht vorhanden ist, ist der von document.getElementById () erhaltene Wert null. Diese Methode gibt entweder einen Knoten zurück oder kehrt Null zurück. Da Null zu diesem Zeitpunkt eine vorhersehbare Ausgabe ist, kann das Rückgabeergebnis mit dem Identitätsbetreiber === oder dem Nicht-Identitäts-Operator! == erkannt werden.

Zusätzlich zu der oben erwähnten Zeichenfolge, Anzahl, Booleschen, undefinierter und Objekt hat der Rückgabewert des Typs des Operators auch Funktion. Aus technischer Sicht sind Funktionen auch Objekte in JavaScript, nicht Datentypen. Funktionen haben jedoch einige besondere Eigenschaften, daher ist es notwendig, Funktionen von anderen Objekten durch den Typeof -Operator zu unterscheiden. Diese Funktion wird später in der Erkennungsfunktion verwendet.

Referenzwerte erkennen

In JavaScript mit Ausnahme der ursprünglichen Werte alle Referenzwerte (auch als Objekte bezeichnet). Häufig verwendete Referenztypen sind: Objekt, Array, Datum und Regexp. Diese Referenztypen sind integrierte Objekte in JavaScript. Der Typeof -Operator gibt bei der Beurteilung dieser Referenztypen "Objekt" zurück.

 console.log (typeof {}); // "Objekt" console.log (typeof []); // "Objekt" console.log (typeof New Date ()); // "Object" console.log (typeof neuer regexp ()); // "Object" console.log (typeof neuer regexp ()); // "Objekt"

Der beste Weg, um einen referenzierten Werttyp zu erkennen, besteht darin, den Instanzoperator zu verwenden. Die grundlegende Syntax von Instanzen ist:

 Wertinstanz des Konstruktors // Datum erkennen if (Wertinstanzdatum) {console.log (value.getingfullyear);} // Erkennen Sie Fehler (Wertinstanz von Fehler) {Wurfwert;} // Normale Ausdruck erkennen if (value Instanceof regexp) {if (value.test (testest (othervale

Ein interessantes Merkmal von Instanz ist, dass es nicht nur den Konstruktor erkennt, der dieses Objekt konstruiert, sondern auch die Prototypkette erkennt. Die Prototypkette enthält viele Informationen, einschließlich des Vererbungsmusters, das zum Definieren des Objekts verwendet wird. Beispielsweise erbt jedes Objekt standardmäßig von Objekt, so dass die Wertinstanz des Objekts jedes Objekts ture zurückgibt. Zum Beispiel:

 var nun = new Date (); console.log (jetzt Instanz des Objekts); // das natureconsole.log (jetzt Instanzdatum); // Der naturinstanze Operator kann auch benutzerdefinierte Typen erkennen, wie z. // die Natureconsole.log (ME Instanz der Person); // die Natur

Der Personentyp wird in diesem Beispielcode erstellt. Die Variable Me ist eine Instanz der Person, also ist ich eine Person, die Person ist. Wie oben erwähnt, werden alle Objekte als Objektfälle angesehen, sodass auch das Objekt von ME eine Ture ist.

Bei der Erkennung integrierter und benutzerdefinierter Typen in JavaScript besteht der beste Weg, dies zu tun, den Instanzbetreiber zu verwenden. Dies ist der einzige Weg, dies zu tun.

Aber es gibt eine ernsthafte Einschränkung. Unter der Annahme, dass beide Browser -Frames (Frames) eine Konstruktor -Person haben und die Personinstanz in Rahmen A in Frame B übergeben wird, werden die folgenden Ergebnisse sein:

console.log (FrameaPersoninstance Instanz von Frameaperson) // Ture

console.log (FrameaPersonInstance Instance von Frambperson) // Falsch

Obwohl die Definitionen der beiden Personen genau gleich sind, gelten sie als unterschiedliche Typen in verschiedenen Rahmen. Es gibt zwei sehr wichtige integrierte Typen, die auch dieses Problem haben: Array und Funktion, sodass sie im Allgemeinen keine Instanz verwenden.

Erkennungsfunktion

Technisch gesehen sind Funktionen in JavaScript Referenztypen, und es gibt auch Funktionskonstruktor. Jede Funktion ist zum Beispiel ein Beispiel:

 Funktion myfunc () {} // schlechtes Schreiben method console.log (MyFuncin -Instanzfunktion); // WAHR

Diese Methode kann jedoch nicht über Frames verwendet werden, da jeder Frame seinen eigenen Funktionskonstruktor hat. Glücklicherweise kann der Typeof -Operator auch für Funktionen verwendet werden und die "Funktion" zurückgibt.

 function myfunc () {} // gute Schreibmethode console.log (typeof myfunc == "Funktion"); // WAHR

Der beste Weg, eine Funktion zu erkennen, besteht darin, Typen zu verwenden, da sie über Rahmen hinweg verwendet werden kann.

Die Verwendung von Typen zum Erkennung von Funktionen ist eine Begrenzung. In IE 8 und früheren IE -Browsern wird Typof verwendet, um festzustellen, dass die Funktionen in Dom -Knoten "Objekt" anstelle von "Funktion" zurückgeben. Zum Beispiel:

 // ieconsole.log (typeof document.createelement); // "Objekt" console.log (typeof document.getElementById); // "Objekt" console.log (typeof document.getElementByTagName); // "Objekt" console.log (typeof document.getElementByTagName); // "Objekt"

Dieses seltsame Phänomen tritt auf, weil Browser Unterschiede in der Implementierung von DOM aufweisen. Kurz gesagt, diese früheren Versionen von IE haben das DOM nicht als integrierte JavaScript-Methode implementiert, was dazu führte, dass der integrierte Typenbetreiber diese Funktionen als Objekte identifiziert. Da das DOM klar definiert ist, nutzen die Entwickler häufig das Wissen, dass ein Objektmitglied existiert, dass es sich um eine Methode handelt.

 // DOM -Methode erkennen if ("querySelectorAll in document) {var mices = document.querySelectorAll (" img ");};};

Dieser Code prüft, ob QuerySelectorAll im Dokument definiert ist, und verwenden Sie diese Methode. Obwohl nicht die ideale Methode, ist es der sicherste Weg zu erkennen, ob die DOM -Methode in IE 8 und früheren Browsern vorhanden ist. In allen anderen Fällen ist der Typeof -Operator die beste Wahl, um JavaScript -Funktionen zu erkennen.

Array erkennen

Eines der ältesten Cross-Domänen-Probleme in JavaScript ist die Übergabe zwischen den Rahmen. Der Entwickler stellte bald fest, dass das Instanz von Array nicht das richtige Ergebnis in diesem Szenario zurückgeben kann. Wie oben erwähnt, hat jeder Frame seinen eigenen Array -Konstruktor, sodass Instanzen in einem Frame nicht in einem anderen Rahmen erkannt werden.

Es wurden viele Nachforschungen darüber gegeben, wie Array -Typen in JavaScript erfasst werden können, und schließlich gab Kangax eine elegante Lösung:

 Funktion isArray (value) {return object.prototype.toString.call (value) === "[Objektarray]";}

Kangax stellte fest, dass das Aufrufen der integrierten Methode eines Werts eines Werts () die Standard-Zeichenfolge in allen Browsern zurückgibt. Für Arrays lautet die zurückgegebene Zeichenfolge "[Objektarray]", und es müssen nicht berücksichtigt werden, welcher Rahmen die Array -Instanz konstruiert ist. Diese Methode ist bei der Identifizierung integrierter Objekte oft sehr nützlich, verwenden Sie diese Methode jedoch nicht für benutzerdefinierte Objekte.

ECMascript5 führt ordentlich.isArray () in JavaScript ein. Der einzige Zweck ist es, genau festzustellen, ob ein Wert ein Array ist. Wie die Funktionen von Kangax kann Array.isArray () auch Werte erkennen, die über Frames übergeben wurden, so viele Bibliotheken der JavaScript -Klasse implementieren diese Methode derzeit ähnlich.

 Funktion isArray (value) {if (typeof array.isarray === "Funktion") {return array.isarray (value);} else {return Object.Prototype.toString.call (value) === "[Objektarray]";}}}

IE 9+, Firefox 4+, Safari 5+, Opera 10.5+ und Chrome implementieren die Array.IsArray () -Methode.

Eigenschaften erkennen

Ein weiteres Szenario, in dem Null (und undefiniert) bei der Erkennung ist, ob ein Attribut in einem Objekt vorhanden ist, z. B.:

 // Schlechtes Schreiben: falsche Werte erkennen if (Objekt [PropertyName]) {// ein Code} // schlechtes Schreiben: Vergleiche mit null if (Object [PropertyName]!

Jedes Urteil im obigen Code überprüft tatsächlich den Wert des Attributs mit dem angegebenen Namen, anstatt zu beurteilen, ob das durch den angegebene Namen genannte Attribut vorhanden ist. Im ersten Urteil ist das Ergebnis fehlerhaft, wenn der Eigenschaftswert ein falscher Wert ist, z.

Der beste Weg, um festzustellen, ob ein Attribut vorhanden ist, besteht darin, den Operator zu verwenden. Der In -Betreiber beurteilt einfach, ob das Eigentum existiert, ohne den Wert des Eigentums zu lesen. Wenn die Eigenschaft des Instanzobjekts aus dem Prototyp des Objekts existiert oder vererbt, wird der Operator true zurückgegeben. Zum Beispiel:

 var object = {count: 0, verwandt: null}; // Gutes Schreiben if ("count" in Object) {// Der Code hier wird ausgeführt} // Schlechtes Schreiben: falsche Werte erkennen, wenn (Objekt ["count"]) {// Der Code hier wird nicht ausgeführt. {// Der Code hier wird nicht ausgeführt}

Wenn Sie nur überprüfen möchten, ob eine bestimmte Eigenschaft des Instanzobjekts vorhanden ist, verwenden Sie die Methode von HaSownProperty (). Alle aus Objekte geerbten JavaScript -Objekte haben diese Methode. Wenn diese Eigenschaft in der Instanz vorhanden ist, gibt sie True zurück (wenn diese Eigenschaft nur im Prototyp existiert, gibt sie falsche zurück). Es ist zu beachten, dass DOM -Objekte in IE 8 und früheren Versionen von IE nicht von Objekt erben, so dass diese Methode nicht eingeschlossen ist. Das heißt, Sie sollten prüfen, ob die Methode des DOM -Objekts vor dem Aufruf von HasownProperty () vorhanden ist.

 // Dies ist eine gute Möglichkeit, wenn (Object.hasownProperty ("verwandt") {// den Code hier ausführen} // Wenn Sie nicht sicher sind, ob es sich um ein DOM -Objekt handelt, schreiben Sie dann, wenn ("HasownProperty" in Object && Object.hasownProperty ("verwandt") {// Execute des Codes hier} den Code} hier}}} hier}

Da es IE 8 und frühere Versionen von IE gibt, verwenden ich bei der Beurteilung, ob die Attribute des Instanzobjekts vorhanden sind, den Operator vor. HasownProperty () wird nur bei der Beurteilung der Instanzeigenschaften verwendet.

Unabhängig davon, wann Sie das Vorhandensein einer Eigenschaft erkennen müssen, verwenden Sie den Operator oder HasownProperty (). Dies kann viele Fehler vermeiden.

Das obige ist die vom Editor eingeführte JavaScript -Erkennung von Originalwerten, Referenzwerten und Attributen. Ich hoffe, es wird für alle hilfreich sein. Wenn Sie Fragen haben, hinterlassen Sie mir bitte eine Nachricht und der Editor wird allen rechtzeitig antworten. Vielen Dank für Ihre Unterstützung auf der Wulin.com -Website!