Trasformazioni implicite in JavaScript e sommario (raccomandato)

Le regole di conversione tra diversi tipi di dati in JavaScript sono le seguenti:

1. Confronto tra oggetti e valori booleani

Quando si confronta un oggetto con un valore booleano, l'oggetto viene prima convertito in una stringa, poi in un numero, mentre il valore booleano viene convertito direttamente in un numero

[] == true; //false [] viene convertito in una stringa '', quindi in un numero 0, true in un numero 1, quindi è false

2. Confronto tra oggetti e stringhe

Quando si confronta un oggetto con una stringa, l'oggetto viene convertito in una stringa e poi confrontato con l'altra.

[1,2,3] == '1,2,3' // true [1,2,3] viene convertito in '1,2,3', quindi confrontato con '1,2,3', quindi il risultato è true;

3. Confronto tra oggetti e numeri

对象和数字进行比较时，对象先转换为字符串，然后转换为数字，再和数字进行比较。

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

4. 字符串和数字比较

字符串和数字进行比较时，字符串转换成数字，二者再比较。

'1' == 1 // true

5. 字符串和布尔值比较

字符串和布尔值进行比较时，二者全部转换成数值再比较。

'1' == true; // true

6. 布尔值和数字比较

布尔值和数字进行比较时，布尔转换为数字，二者比较。

true == 1 // true

许多刚开始接触js的童鞋看到这么多的转换规则就懵圈了，其实规律很简单，大家可以记下边这个图

如图，任意两种类型比较时，如果不是同一个类型比较的话，则按如图方式进行相应类型转换，如对象和布尔比较的话，对象 => 字符串 => 数值 布尔值 => 数值。
另外，我们来看下一些需要'特别照顾'的。

来看一个有趣的题

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

这两个的结果都是true，第一个是，对象 => 字符串 => 数值0 false转换为数字0，这个是true应该没问题，
第二个前面多了个!，则直接转换为布尔值再取反，转换为布尔值时，空字符串('', NaN, 0, null, undefined)这几个外返回的都是true，所以![]这个[] => true取反为false，所以[] == false为true。

还有一些需要记住的，像：

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

曾经看到过这样一个代码：　 (!(~+[])+{})[--[~+""][+[]]*[~+[]]+~~!+[]]+({}+[])[[~!+[]*~+[]]] = sb ，你敢相信，当时就吓了宝宝一跳。

刚开始接触的时候，Js让我很困惑，正是因为它‘善变'，下面我来总结一下：

7. JS的数据类型Number, Boolean, String, Undefined, Null, Symbol (es6新定义的) e Object (注： Array是特殊的Object)

　　　　Il tipo restituito da typeof sono 7: number boolean string object undefined function

MDN descrive JavaScript così: JavaScript è un linguaggio di programmazione debolmente tipizzato o dinamico. Questo significa che non è necessario dichiarare preventivamente il tipo delle variabili, il tipo viene determinato automaticamente durante l'esecuzione del programma. Questo significa che è possibile utilizzare la stessa variabile per salvare dati di diversi tipi.

8. Vediamo ora le comuni conversioni implicite:

　　Tipi primitivi:

　　　Con l'operazione degli operatori (+, -, *, /, %), la conversione dei tipi

　　　　Operatore (+) : 　　

　　　　　　　　　　

　　　　　　　　　　　　　　　　　　　　

　　　　　　Sommario: Quando l'operatore di somma (+) è utilizzato con String e altri tipi, altri tipi vengono convertiti in String; in altri casi, vengono convertiti in tipo Number, nota: undefined viene convertito in Number come 'NaN', qualsiasi somma tra Number e NaN è NaN.

　　　　　　　 　　Con altri operatori, i tipi primitivi vengono convertiti in Number, i tipi Stringa con caratteri come: '1a', 'a1' vengono convertiti in NaN, come undefined.

　　　　　　Consiglio: (1) NaN non è uguale a nessun altro valore, né a se stesso, quindi per verificare se un valore è NaN, si può utilizzare "!==".　　

　　　　　　　　 (2) Le conversioni in tipo Booleano false includono: null, 0, '', undefined, NaN, false　　

　　　　　　　　(3) number() e parseInt() possono convertire gli oggetti in tipo Number, la funzione Number è molto più rigorosa rispetto a parseInt(). Sostanzialmente, se anche una sola lettera non può essere convertita in numero, l'intera stringa viene convertita in NaN.　　

　　

　　Tipo Object

　　　　Quando l'oggetto si calcola con i tipi primitivi:

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

　　　　　　　　　　　

　　　　　　　　　　　　　　　　　　

　　　　　　

　　　　　　　　　　　　Quando si utilizza Number() e String() per convertire obj, obj1

　　　　　　　　

　　　　　　　　　　　　Sommario: Il tipo Number chiama prima valueOf(), il tipo String chiama prima toString(), se il risultato è un valore originale, viene restituito il valore originale, altrimenti continua a utilizzare toString o valueOf(), continua a calcolare, se il risultato non è ancora un valore originale, viene lanciata un'eccezione di tipo.　

　　　　Ecco il caso:

　　　　

Perché {} + [] = 0? Perché JavaScript, durante l'esecuzione, considera il primo {} come un blocco di codice vuoto, quindi è equivalente a +[] = 0. Allo stesso modo, {} +5 = 5.

Sommario:

1. Gli errori di tipo possono essere nascosti dalla conversione di tipo.

2. Il simbolo '+' può rappresentare sia la connessione di stringhe che l'addizione aritmetica, a seconda dei suoi operandi. Se uno di essi è una stringa, allora è una connessione di stringhe.

3. Gli oggetti si trasformano in numeri tramite il metodo valueOf e in stringhe tramite il metodo toString.

4. Gli oggetti che dispongono del metodo valueOf devono definire un metodo toString corrispondente per restituire la rappresentazione in stringa di numeri equivalenti.

5. Quando si verificano variabili non definite, è consigliabile utilizzare typeof o confrontarle con undefined, invece di utilizzare direttamente l'operatore di valore booleano.

Sommario

Quello che è stato descritto sopra è un'elaborazione di alcune trasformazioni implicite e una sommario in JavaScript presentato dall'autore, speriamo che sia utile. Se avete qualsiasi domanda, lasciate un messaggio e l'autore risponderà prontamente. Ringraziamo anche il supporto di tutti per il manuale di urla!

Dichiarazione: il contenuto di questo articolo è stato raccolto da Internet, di proprietà del rispettivo autore, il contenuto è stato contribuito e caricato autonomamente dagli utenti di Internet, questo sito non detiene i diritti di proprietà, non è stato elaborato manualmente e non assume responsabilità legali correlate. Se trovi contenuti sospetti di violazione del copyright, ti preghiamo di inviare una e-mail a notice#oldtoolbag.com (sostituisci # con @) per segnalare il problema e fornire prove pertinenti. Una volta verificata, questo sito rimuoverà immediatamente il contenuto sospetto di violazione del copyright.