Zusammenfassung einiger impliziter Konvertierungen in JS

Dieses Mal werde ich Ihnen eine Zusammenfassung einiger impliziter Konvertierungen in JS geben. Was sind die Vorsichtsmaßnahmen bei der Verwendung der impliziten JS-Konvertierung? Die Vergleichs- und Konvertierungsregeln zwischen verschiedenen

Datentypen in

js lauten wie folgt:

1. Vergleich von Objekten und booleschen Werten

Beim Vergleich von Objekten und booleschen Werten wird das Objekt zunächst in eine Zeichenfolge und dann in eine Zahl umgewandelt. Der boolesche Wert wird direkt in eine Zahl umgewandelt

[] == true; //false []转换为字符串'',然后转换为数字0,true转换为数字1，所以为false

2. Objekt- und String-Vergleich

Beim Vergleich von Objekten und Zeichenfolgen wird das Objekt in eine Zeichenfolge umgewandelt und anschließend werden die beiden verglichen.

[1,2,3] == '1,2,3' // true [1,2,3]转化为'1,2,3'，然后和'1,2,3'， so结果为true;

3. Vergleich von Objekten und Zahlen

Beim Vergleich eines Objekts mit einer Zahl wird das Objekt zunächst in eine Zeichenfolge umgewandelt, dann in eine Zahl umgewandelt und dann mit der Zahl verglichen.

[1] == 1; // true `对象先转换为字符串再转换为数字，二者再比较 [1] => '1' => 1 所以结果为true

4. Zeichenfolgen- und Zahlenvergleich

Beim Vergleich von Zeichenfolgen und Zahlen werden die Zeichenfolgen in Zahlen umgewandelt und die beiden verglichen.

'1' == 1 // true

5. String- und Boolescher Vergleich

Beim Vergleich von Strings und booleschen Werten werden beide in numerische Werte umgewandelt und anschließend verglichen.

'1' == true; // true

6. Boolescher und Zahlenvergleich

Beim Vergleich boolescher Werte mit Zahlen wird der boolesche Wert in eine Zahl umgewandelt und die beiden verglichen.

true == 1 // true

Wenn Sie zwei beliebige Typen vergleichen und nicht vom gleichen Typ sind, führen Sie die entsprechende Typkonvertierung durch, wie in der Abbildung gezeigt. Zum Beispiel beim Vergleich von Objekten mit Boolean, Objekt => ; string=> value boolean=>
Außerdem werfen wir einen Blick auf einige Dinge, die „besondere Sorgfalt“ erfordern.

Werfen wir einen Blick auf eine interessante Frage

[] == false;
![] == false;

Die Ergebnisse dieser beiden sind „true“: „object => value 0“ wird in „true“ umgewandelt Der zweite! Konvertieren Sie ihn dann direkt in einen booleschen Wert und negieren Sie ihn. Bei der Konvertierung in einen booleschen Wert werden die leeren Zeichenfolgen (''), NaN, 0, null und undefiniert zurückgegeben [] => ; Die Negation von true ist falsch, also ist [] == false wahr.

Es gibt noch einige weitere Dinge, die Sie sich merken sollten, wie zum Beispiel:

undefined == null //true undefined和null 比较返回true，二者和其他值比较返回false
Number(null) //0

Ich habe einmal so einen Code gesehen:

, können Sie es glauben, es hat dem Baby damals Angst gemacht. (!(~+[])+{})[--[~+""][+[]]*[~+[]]+~~!+[]]+({}+[])[[~!+[]*~+[]]] = sb

Als ich zum ersten Mal damit in Kontakt kam, war JS für mich sehr verwirrend, gerade wegen seiner „Unbeständigkeit“. Lassen Sie es mich unten zusammenfassen:

7. JS-Datentypen : Number, Boolean, String, Undefiniert, Null, Symbol (neu definiert in es6) und Object (Hinweis: Array ist ein spezielles Objekt)

7 von typeof zurückgegebene Typen: Zahl boolesche Zeichenfolge Objekt undefinierte Objektfunktion

MDN führt Javascript wie folgt ein: JavaScript ist eine schwach typisierte oder dynamische Sprache. Dies bedeutet, dass Sie den Typ der Variablen nicht im Voraus deklarieren müssen, sondern der Typ wird automatisch während der Ausführung des Programms bestimmt. Das bedeutet auch, dass Sie dieselbe Variable verwenden können, um verschiedene Datentypen zu speichern

8. Werfen wir einen Blick auf gängige implizite Konvertierungen:

 Grundtyp:

Bei Operatoren (+,-,*,/,%) ist der Konvertierungstyp

„+“-Operator: ˆ ˆ ˆ ˆ Zusammenfassung: Bei Verwendung des Pluszeichenoperators werden String und andere Typen in String konvertiert; in anderen Fällen werden sie in Number als „NaN“ konvertiert, und jede zu NaN hinzugefügte Zahl wird konvertiert be ist NaN.

Wenn andere Operatoren verwendet werden, werden die Grundtypen in Zahlenzeichenfolgentypen mit Zeichen wie „1a“, „a1“ konvertiert, was dasselbe wie „undefiniert“ ist.

Tipp: (1) NaN entspricht keinem Wert, auch nicht sich selbst. Um zu bestimmen, ob ein Wert NaN ist, verwenden Sie „! ==".  

        (2) Die Konvertierung in den booleschen Typ als falsch umfasst: null, 0, '', undefiniert, NaN, falsch   

        （3）number（） 与 parseInt（） 都可以将对象转化为Number类型，Number函数要比parseInt函数严格很多。基本上，只要有一个字符无法转成数值，整个字符串就会被转为NaN。    

  Object类型

    当object与基本类型运算时：

var obj = {
  toString: function(){
    return 6;
  },
  valueOf: function(){
    return 5;
  }
};
var obj1 = {
  valueOf: function(){
    return 'a';
  },
  toString: function(){
    return 'b';
  }
};

  总结： Number类型会先调用valueOf(), String类型会先调用toString(),  如果结果是原始值，则返回原始值，否则继续用toString 或 valueOf(),继续计算，如果结果还不是原始值，则抛出一个类型错误; 

为什么 {} + [] = 0 ?  因为 javascript在运行时, 将 第一次{} 认为是空的代码块，所以就相当于 +[] = 0.  还有 {} +5 = 5, 同理。

总结:

1. 类型错误有可能会被类型转换所隐藏。

2. “+”既可以表示字符串连接，又可以表示算术加，这取决于它的操作数，如果有一个为字符串的，那么，就是字符串连接了。

3. 对象通过valueOf方法，把自己转换成数字，通过toString方法，把自己转换成字符串。

4.具有valueOf方法的对象，应该定义一个相应的toString方法，用来返回相等的数字的字符串形式。

5.检测一些未定义的变量时，应该使用typeOf或者与undefined作比较，而不应该直接用真值运算。

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

Das obige ist der detaillierte Inhalt vonZusammenfassung einiger impliziter Konvertierungen in JS. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!