Petua conversion_javascript jenis tersirat JavaScript

Jenis data JavaScript sangat lemah (jika tidak, ia tidak akan dipanggil bahasa yang ditaip lemah)! Apabila menggunakan operator aritmetik, jenis data pada kedua-dua belah operator boleh menjadi sewenang-wenangnya. Contohnya, rentetan boleh ditambah pada nombor. Sebab mengapa operasi boleh dilakukan antara jenis data yang berbeza adalah kerana enjin JavaScript akan melakukan penukaran jenis tersirat padanya sebelum operasi Berikut ialah penambahan jenis angka dan jenis Boolean:

Salin kod Kod adalah seperti berikut:

3 + benar; // 4

Hasilnya ialah nilai angka! Jika ia berada dalam persekitaran C atau Java, operasi di atas pasti akan menyebabkan ralat kerana jenis data pada kedua-dua belah operator tidak konsisten! Walau bagaimanapun, dalam JavaScript, hanya dalam beberapa kes, jenis yang salah akan menyebabkan ralat, seperti semasa memanggil bukan fungsi, atau membaca sifat null atau tidak ditentukan, seperti berikut:

Salin kod Kod adalah seperti berikut:

"hello"(1); // ralat: bukan fungsi
null.x; // ralat: tidak boleh membaca sifat 'x' null

Dalam kebanyakan kes, JavaScript tidak akan membuat ralat, tetapi akan melakukan penukaran jenis yang sepadan secara automatik. Sebagai contoh, pengendali aritmetik seperti -, *, /, dan % akan menukarkan operan mereka kepada nombor, tetapi tanda "+" sedikit berbeza Dalam beberapa kes, ia adalah tanda tambah aritmetik, dan dalam kes lain, ia ialah rentetan simbol Sambungan, butiran khusus bergantung pada operannya, seperti berikut:

Salin kod Kod adalah seperti berikut:

2 + 3; // 5
"hello" + "world"; // "hello world"

Tetapi apakah hasilnya jika rentetan dan nombor ditambah? JavaScript akan menukar nombor kepada aksara secara automatik, tidak kira sama ada nombor atau rentetan didahulukan, seperti berikut:

Salin kod Kod adalah seperti berikut:

"2" + 3; // "23"
2 + "3"; // "23"

Hasil penambahan rentetan dan nombor ialah rentetan Hasil penambahan rentetan dan nombor ialah rentetan. ! ! ! ! !

Selain itu, perlu diperhatikan bahawa arah operasi "+" adalah dari kiri ke kanan, seperti berikut:

Salin kod Kod adalah seperti berikut:

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

Ini bersamaan dengan:

Salin kod Kod adalah seperti berikut:

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

Sebaliknya, keputusan berikut adalah berbeza:

Salin kod Kod adalah seperti berikut:

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

Walau bagaimanapun, penukaran jenis tersirat kadangkala menyembunyikan beberapa ralat, contohnya, null akan ditukar kepada 0 dan undefined akan ditukar kepada NaN. Perlu diingat bahawa NaN dan NaN tidak sama (ini disebabkan oleh ketepatan nombor titik terapung), seperti berikut:

Salin kod Kod adalah seperti berikut:

var x = NaN;
x === NaN; // palsu

Walaupun JavaScript menyediakan isNaN untuk mengesan sama ada nilai tertentu ialah NaN, ini tidak begitu tepat kerana terdapat proses penukaran tersirat sebelum memanggil fungsi isNaN, yang akan menukarkan Nilai yang bukan asalnya NaN ditukar kepada NaN , seperti berikut:

Salin kod Kod adalah seperti berikut:

isNaN("foo"); // benar
isNaN(undefined); // benar
isNaN({}); // benar
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!