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:

Code kopieren Der Code lautet wie folgt:

3 + wahr; // 4

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:

Code kopieren Der Code lautet wie folgt:

"hello"(1); // Fehler: keine Funktion
null.x; // Fehler: Eigenschaft 'x' von null
kann nicht gelesen werden

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:

Code kopieren Der Code lautet wie folgt:

2 + 3; // 5
„Hallo“ + „Welt“; // „Hallo Welt“

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:

Code kopieren Der Code lautet wie folgt:

„2“ + 3; // „23“
2 + „3“; // „23“

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:

Code kopieren Der Code lautet wie folgt:

1 + 2 + „3“; // „33“

Dies entspricht:

Code kopieren Der Code lautet wie folgt:

(1 + 2) + „3“; // „33“

Im Gegensatz dazu sind die folgenden Ergebnisse unterschiedlich:

Code kopieren Der Code lautet wie folgt:

1 + „2“ ​​+ 3; // „123“

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:

Code kopieren Der Code lautet wie folgt:

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

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:

Code kopieren Der Code lautet wie folgt:

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

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;

Code kopieren Der Code lautet wie folgt:

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

Eine genauere Möglichkeit, Undefiniert zu erkennen, ist die Verwendung des Operationstyps:

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

Diese Schreibweise kann zwischen 0 und undefiniert unterscheiden:

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

Eine andere Methode besteht darin, Parameter zum Vergleich mit undefinierten Parametern zu verwenden, wie folgt:

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

Zusammenfassung:

1. Typfehler können durch Typkonvertierung ausgeblendet werden.

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

3. Das Objekt wandelt sich über die valueOf-Methode in eine Zahl und über die toString-Methode in einen String um.

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

5. Bei der Erkennung einiger undefinierter Variablen sollte typeOf oder ein Vergleich mit undefiniert anstelle der direkten True-Value-Operation verwendet werden.

Das ist es für alle, die sich mit der impliziten Typkonvertierung in JavaScript befassen. Ich hoffe, es wird Ihnen hilfreich sein!