Tipps zum impliziten JavaScript-Typ „conversion_javascript'.

JavaScripts Datentypen sind sehr schwach (sonst würde man es nicht als schwach typisierte Sprache bezeichnen)! 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 eine implizite Typkonvertierung für sie durchführt. Im Folgenden werden numerische Typen und boolesche Typen hinzugefügt:

Das Ergebnis ist ein numerischer Wert! Wenn es sich um eine C- oder Java-Umgebung handelt, führt die obige Operation definitiv 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. B. beim Aufrufen einer Nichtfunktion oder beim Lesen einer Null- oder undefinierten Eigenschaft wie folgt:

In den meisten Fällen macht JavaScript keine 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 eine Zeichenfolge. Das Verbindungssymbol hängt wie folgt von seinen Operanden ab:

Aber was wäre das Ergebnis, wenn Zeichenfolgen und Zahlen hinzugefügt würden? JavaScript wandelt Zahlen wie folgt automatisch in Zeichen um, unabhängig davon, ob die Zahl oder die Zeichenfolge an erster Stelle steht:

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

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

Dies entspricht:

Im Gegensatz dazu sind die folgenden Ergebnisse unterschiedlich:

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

Obwohl JavaScript isNaN bereitstellt, um zu erkennen, ob ein bestimmter Wert NaN ist, ist dies nicht sehr genau, da vor dem Aufruf der isNaN-Funktion ein impliziter Konvertierungsprozess stattfindet, der die Werte, die ursprünglich nicht NaN sind, in NaN konvertiert , wie folgt:

Nachdem wir den obigen Code mit isNaN getestet haben, haben wir festgestellt, dass Strings, undefinierte und sogar Objekte alle „true“ zurückgegeben haben! ! ! Allerdings können wir nicht sagen, dass sie auch NaN sind, oder? Alles in allem lautet das Fazit: isNaN-Erkennung von NaN ist nicht zuverlässig! ! !

Glücklicherweise gibt es eine zuverlässige und genaue Möglichkeit, NaN zu erkennen. Wir alle wissen, dass NaN die einzige Zahl ist, die sich selbst nicht gleicht. Dann können wir das Ungleichheitszeichen (!==) verwenden, um zu bestimmen, ob eine Zahl sich selbst entspricht, sodass NaN wie folgt erkannt 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 diesen Modus auch wie folgt als Funktion definieren:

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

OK, so einfach ist die NaN-Erkennungsmethode. Lassen Sie uns weiter über die implizite Konvertierung von Objekten sprechen!

Objekte können wie folgt in primitive Werte umgewandelt werden:

"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 die valueOf-Funktion in Zahlen umgewandelt werden. Natürlich können Sie diese valueOf-Funktion auch wie folgt anpassen:

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

Wenn ein Objekt sowohl über die valueOf-Methode als auch über die toString-Methode verfügt, wird die valueOf-Methode immer zuerst wie folgt aufgerufen:

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

In den meisten Fällen ist dies jedoch nicht das, was wir wollen. Versuchen Sie im Allgemeinen, die durch valueOf und toString dargestellten Werte gleich zu machen (obwohl die Typen unterschiedlich sein können).

Die letzte Art der erzwungenen Typkonvertierung wird oft als „Wahrheitsoperation“ bezeichnet, z. B. if, ||, &&. Ihre Operanden sind nicht unbedingt boolesch. 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: falsch, 0, -0, „“, NaN, null, undefiniert, da es Zahlen, Zeichenfolgen und Objekte mit falschen Werten gibt, also Es Es ist nicht sehr sicher, die Wahrheitswertkonvertierung direkt zu verwenden, um zu bestimmen, ob die Parameter einer Funktion übergeben werden. Beispielsweise gibt es 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;

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

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

if (x === undefined) { ... }

Zusammenfassung: