Fassen Sie die vier Situationen der impliziten JavaScript-Typkonvertierung zusammen

Der folgende Editor bietet Ihnen eine Zusammenfassung der vier Situationen, in denen eine implizite JavaScript-Typkonvertierung vorliegt (ein Artikel, den Sie unbedingt lesen müssen). Der Herausgeber findet es ziemlich gut, deshalb werde ich es jetzt mit Ihnen teilen und es allen als Referenz geben. Folgen wir dem Editor und werfen wir einen Blick darauf.

Im Allgemeinen gibt es vier Situationen, in denen JavaScript den Datentyp der Variablen konvertiert.

Verzeichnis

* if中的条件会被自动转为Boolean类型
 * 会被转为false的数据
 * 会被转为true的数据
* 参与+运算都会被隐式的转为字符串
 * 会被转为空字符串的数据
 * 会被转为字符串的数据
 * 会被转为数据类型标记的数据
* 参与*运算都会被隐式的转为数字
 * 会被转为0的数据
 * 会被转为1的数据
 * 会被转为NaN的数据
* == 运算符
 * 为true的时候
 * 为false的时候

Die Bedingungen in if werden automatisch in den booleschen Typ

konvertiert Daten, die in „falsch“

if(false) console.log(2333)
if('') console.log(2333)
if(null) console.log(2333)
if(undefined) console.log(2333)
if(NaN) console.log(2333)

umgewandelt werden, werden in „wahr“ umgewandelt. Daten

if(true) console.log(2333) // 2333
if('test') console.log(2333) // 2333
if([]) console.log(2333) // 2333
if({}) console.log(2333) // 2333

, die an der +-Operation teilnehmen sei implizit In einen String konvertieren

Die Daten werden in einen leeren String konvertiert

'str-' + '' // str-
'str-' + []

Die Daten werden in einen String konvertiert

'str-' + '1' // "str-1"
'str-' + 1 // "str-1"
'str-' + false // "str-false"
'str-' + true // "str-true"
'str-' + null // "str-null"
'str-' + undefined // "str-undefined"
'str-' + NaN // "str-NaN"

wird in nach Datentyp markierte Daten umgewandelt

'str-' + {} // "str-[object Object]"
'str-' + {a:1} // "str-[object Object]"

Die Teilnahme an *-Operationen wird implizit in Zahlen umgewandelt

Daten, die in 0 umgewandelt werden

2 * '' // 0
2 * [] // 0
2 * false // 0

Daten, die in 1 umgewandelt werden

2 * '1' // 2
2 * [1] // 2
2 * true // 2

Daten, die in NaN konvertiert werden

2 * {} // NaN
2 * {a:1} // NaN

== Operator

ist wahr, wenn

0 == false // true
0 == '' // true
0 == '0' // true
0 == [] // true
0 == [0] // true

1 == true // true
1 == '1' // true
1 == [1] // true

[1] == true // true
[] == false // true

ist falsch,

0 == {} // false
0 == null // false
0 == undefined // false
0 == NaN // false

1 == {} // false
1 == null // false
1 == undefined // false
1 == NaN // false

[] == [] // false
[1] == [1] // false
[1] == {} // false
[1] == {a:1} // false
[1] == false // false
[1] == null // false
[1] == undefined // false
[1] == NaN // false

{} == {} // false
{a:1} == {a:1} // false

Hinweis: leeres Array[], im +-Operator Folgendes wird konvertiert in die leere Zeichenfolge '' umgewandelt und der *-Operator in die Zahl 0 umgewandelt. Aber in der if-Anweisung wird es wahr.

Das obige ist der detaillierte Inhalt vonFassen Sie die vier Situationen der impliziten JavaScript-Typkonvertierung zusammen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!