Was ist eine implizite Typkonvertierung? Einführung in die implizite Typkonvertierung von js

In diesem Artikel erfahren Sie, was eine implizite Typkonvertierung ist. Die Einführung in die implizite Typkonvertierung von js hat einen gewissen Referenzwert. Freunde in Not können darauf verweisen.

Die Datentypen von JavaScript sind sehr schwach. Bei der Verwendung arithmetischer Operatoren können die Datentypen auf beiden Seiten des Operators beliebig sein. Beispielsweise kann eine Zeichenfolge zu einer Zahl hinzugefügt werden. Der Grund, warum Operationen zwischen verschiedenen Datentypen ausgeführt werden können, liegt darin, dass die JavaScript-Engine vor der Operation stillschweigend implizite Typkonvertierungen durchführt. Das Folgende ist die Hinzufügung numerischer Typen und boolescher Typen:

3 + true; 
// 结果：4

Das Ergebnis ist eine Zahl Wert! In einer C- oder Java-Umgebung führt die obige Operation zu einem Fehler, da die Datentypen auf beiden Seiten des Operators inkonsistent sind. In JavaScript führt der falsche Typ jedoch nur in wenigen Fällen zu einem Fehler, z als Aufruf einer Nichtfunktion oder Lesen Wenn Null- oder undefinierte Attribute verwendet werden, lautet dies wie folgt:

"hello"(1); 
//结果： error: not a function
null.x; 
// 结果：error: cannot read property 'x' of null

In den meisten Fällen macht JavaScript keinen Fehler, sondern führt automatisch die entsprechende Typkonvertierung durch. Beispielsweise wandeln arithmetische Operatoren wie -, *, / und % ihre Operanden in Zahlen um, aber das „+“-Zeichen ist etwas anders. In einigen Fällen ist es ein arithmetisches Pluszeichen, in anderen Fällen ist es ein Pluszeichen ist ein String. Das Verbindungssymbol hängt wie folgt von seinen Operanden ab:

2 + 3; 
//结果： 5
"hello" + " world"; 
// 结果："hello world"

Wenn jedoch Strings und Zahlen hinzugefügt werden, wandelt JavaScript die Zahlen automatisch in Zeichen um, unabhängig davon, ob die Zahlen oder Strings zuerst kommen. , wie folgt:

"2" + 3; 
// 结果："23"
2 + "3";
 //结果： "23"

Das Ergebnis der Addition einer Zeichenfolge und einer Zahl ist eine Zeichenfolge!

Es ist zu beachten, dass die Betätigungsrichtung von „+“ von links nach rechts verläuft, wie folgt:

1 + 2 + "3"; 
// "33"

Dies entspricht dem Folgenden:

(1 + 2) + "3"; 
// "33"

Vergleiche unten , die folgenden Ergebnisse sind unterschiedlich:

1 + "2" + 3; 
// "123"

Allerdings verbirgt die implizite Typkonvertierung manchmal einige Fehler, zum Beispiel wird null in 0 konvertiert und undefiniert wird in NaN konvertiert. Es ist zu beachten, dass NaN und NaN nicht gleich sind (dies liegt an der Genauigkeit von Gleitkommazahlen), wie folgt:

var x = NaN;
x === NaN; // false

Obwohl JavaScript isNaN bereitstellt, um zu erkennen, ob ein bestimmter Wert NaN ist, Dies ist nicht sehr genau, da es vor dem Aufruf der isNaN-Funktion einen impliziten Konvertierungsprozess gibt, der Werte, die nicht NaN sind, wie folgt in NaN konvertiert:

isNaN("foo"); // true
isNaN(undefined); // true
isNaN({}); // true
isNaN({ valueOf: "foo" }); // true

Der obige Code, nachdem wir isNaN verwendet haben Zum Testen haben wir herausgefunden, dass Strings, undefinierte Objekte und sogar Objekte alle „true“ zurückgegeben haben! ! ! Aber sie sind nicht NaN.

Kurz gesagt: Die isNaN-Erkennung von NaN ist nicht zuverlässig! ! !

Es gibt eine zuverlässige und genaue Möglichkeit, NaN zu erkennen.

Wir alle wissen, dass nur NaN nicht sich selbst gleich ist. Sie können das Ungleichheitszeichen (!==) verwenden, um festzustellen, ob NaN wie folgt ermittelt werden kann 🎜>

var a = NaN;
a !== a; // true
var b = "foo";
b !== b; // false
var c = undefined;
c !== c; // false
var d = {};
d !== d; // false
var e = { valueOf: "foo" };
e !== e; // false

Wir können dieses Muster auch wie folgt als Funktion definieren:

function isReallyNaN(x) {
    return x !== x;
}

Implizite Konvertierung von Objekten

Objekte können in primitive Werte konvertiert werden. Die gebräuchlichste Methode besteht darin, es wie folgt in einen String umzuwandeln:

"the Math object: " + Math; // "the Math object: [object Math]"
"the JSON object: " + JSON; // "the JSON object: [object JSON]"

Das Objekt wird durch Aufruf seiner toSting-Funktion in einen String umgewandelt. Sie können es manuell aufrufen, um Folgendes zu überprüfen:

Math.toString(); // "[object Math]"
JSON.toString(); // "[object JSON]"

In ähnlicher Weise können Objekte auch über den Wert der Funktion in Zahlen umgewandelt werden. Natürlich können Sie diesen Wert auch wie folgt anpassen:

"J" + { toString: function() { return "S"; } }; // "JS"
2 * { valueOf: function() { return 3; } }; // 6

Wenn ein Objekt auch die Methode valueOf und die Methode toString hat, dann Die value Of-Methode wird immer zuerst wie folgt aufgerufen:

var obj = {
    toString: function() {
        return "[object MyObject]";
    },
    valueOf: function() {
        return 17;
    }
};
"object: " + obj; // "object: 17"

Versuchen Sie im Allgemeinen, die durch value Of und toString dargestellten Werte gleich zu machen (obwohl die Typen unterschiedlich sein können).

Die letzte Art der erzwungenen Typkonvertierung wird oft als „Wahrheitswertoperation“ bezeichnet, z. B. wenn, ||, && ihre Operanden nicht unbedingt boolesch sind. JavaScript konvertiert einige nicht-boolesche Werte mithilfe einfacher Konvertierungsregeln in boolesche Werte. Die meisten Werte werden in wahr umgewandelt, nur wenige sind falsch, sie sind

: false, 0, -0, "", NaN, null, undefiniert, da es Zahlen, Zeichenfolgen und Objekte gibt Der Wert ist falsch, daher ist es nicht sehr sicher, die Konvertierung von wahren Werten direkt zu verwenden, um zu bestimmen, ob die Parameter einer Funktion übergeben werden. Es gibt beispielsweise eine Funktion, die optionale Parameter mit Standardwerten haben kann, wie folgt:

function point(x, y) {
if (!x) {
    x = 320;
}
if (!y) {
    y = 240;
}
    return { x: x, y: y };
}

Diese Funktion ignoriert alle Parameter, deren wahrer Wert falsch ist, einschließlich 0, -0; > Eine genauere Möglichkeit, undefiniert zu erkennen, ist die Verwendung des Operationstyps:

point(0, 0); // { x: 320, y: 240 }

Diese Schreibweise kann zwischen 0 und undefiniert unterscheiden:

function point(x, y) {
if (typeof x === "undefined") {
    x = 320;
}
if (typeof y === "undefined") {
    y = 240;
}
    return { x: x, y: y };
}

Eine andere Methode besteht darin, Parameter zum Vergleich mit undefiniert zu verwenden . Wie folgt:

point(); // { x: 320, y: 240 }
point(0, 0); // { x: 0, y: 0 }

Zusammenfassung:

1.

2. „+“ kann je nach Operanden sowohl eine String-Verkettung als auch eine arithmetische Addition darstellen. Wenn einer davon ein String ist, dann handelt es sich um eine String-Verkettung.

3. Das Objekt wandelt sich durch die Methode value Of in eine Zahl und durch die Methode toString in eine Zeichenfolge um.

4. Objekte mit dem Wert Of-Methoden sollten eine entsprechende toString-Methode definieren, um gleiche Zahlen in String-Form zurückzugeben.

5. Bei der Erkennung einiger undefinierter Variablen sollte der Typ „Of“ oder der Vergleich mit „undefiniert“ anstelle der direkten True-Value-Operation verwendet werden.

Verwandte Empfehlungen:

Zusammenfassung der impliziten JS-Typkonvertierung

Wie verwende ich die implizite Konvertierung? Fassen Sie die Verwendung impliziter Konvertierungsbeispiele zusammen

Eine kurze Einführung in die implizite Typkonvertierung von JavaScript-Datentypen_Javascript-Fähigkeiten

Das obige ist der detaillierte Inhalt vonWas ist eine implizite Typkonvertierung? Einführung in die implizite Typkonvertierung von js. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!