Résumé de quelques conversions implicites en JS

Cette fois, je vais vous apporter un résumé de l'utilisation de la conversion implicite JS. Quelles sont les précautions lors de l'utilisation de la conversion implicite JS. Voici des cas pratiques, jetons un coup d'œil. Les règles de comparaison et de conversion entre les différents

js sont les suivantes :

1. Comparaison des objets et des valeurs booléennes

Lors de la comparaison d'objets et de valeurs booléennes, l'objet est d'abord converti en chaîne puis converti en nombre. La valeur booléenne est directement convertie en nombre

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

. 2. Comparaison d'objets et de chaînes

Lors de la comparaison d'objets et de chaînes, l'objet est converti en chaîne, puis les deux sont comparés.

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

3. Comparaison des objets et des nombres

Lors de la comparaison d'un objet avec un nombre, l'objet est d'abord converti en chaîne, puis converti en nombre, puis comparé au nombre.

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

4. Comparaison de chaînes et de nombres

Lorsque des chaînes et des nombres sont comparés, les chaînes sont converties en nombres, puis les deux sont comparés.

'1' == 1 // true

5. Comparaison de chaînes et de booléens

Lors de la comparaison de chaînes et de valeurs booléennes, les deux sont converties en valeurs numériques puis comparées.

'1' == true; // true

6. Comparaison booléenne et numérique

Lors de la comparaison de valeurs booléennes avec des nombres, le booléen est converti en nombre et les deux sont comparés.

true == 1 // true

Lors de la comparaison de deux types, s'ils ne sont pas du même type, la conversion de type correspondante sera effectuée comme indiqué dans la figure. Par exemple, si l'objet et le booléen sont. comparé, object => ; string=> valeur boolean=>
De plus, examinons certaines choses qui nécessitent des « soins particuliers ».

Jetons un coup d'œil à une question intéressante

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

Les résultats de ces deux sont tous deux vrais. Le premier est object => string => value 0 false converti en nombre 0. Cela devrait être vrai si c'est vrai
Il y a un extra devant. le second ! Ensuite, convertissez-le directement en valeur booléenne, puis annulez-le. Une fois converti en valeur booléenne, la chaîne vide (''), NaN, 0, null et undefined retourneront toutes vrai, donc []this[ ! ] => ; La négation de vrai est fausse, donc [] == false est vrai.

Il y a d'autres choses à retenir, comme :

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

J'ai vu une fois un tel code : (!(~+[])+{})[--[~+""][+[]]*[~+[]]+~~!+[]]+({}+[])[[~!+[]*~+[]]] = sb , peux-tu le croire, ça faisait peur au bébé à ce moment-là.

Lorsque je suis entré en contact avec lui pour la première fois, JS m’a semblé très déroutant, précisément à cause de son « inconstance ». Permettez-moi de le résumer ci-dessous :

. 7. Types de données JS  : Nombre, Booléen, Chaîne, Non défini, Null, Symbole (nouvellement défini dans es6) et Objet (Remarque : le tableau est un objet spécial)

7 types renvoyés par typeof : nombre chaîne booléenne objet fonction objet non définie

MDN introduit Javascript comme ceci : JavaScript est un langage faiblement typé ou dynamique. Cela signifie que vous n'avez pas besoin de déclarer le type de la variable à l'avance, le type sera déterminé automatiquement lors de l'exécution du programme. Cela signifie également que vous pouvez utiliser la même variable pour contenir différents types de données

8. Jetons un coup d'œil aux conversions implicites courantes :

 Type de base :

Lors de l'exploitation d'opérateurs (+,-,*,/,%), le type de conversion est

Opérateur « + » : ˆ ˆ ˆ ˆ Résumé : lors de l'utilisation de l'opérateur de signe plus, les types String et autres seront convertis en String ; dans les autres cas, ils seront convertis en type Number. Remarque : undefined est converti en Number sous la forme "NaN", et tout nombre ajouté à NaN le sera. be est NaN.

Lorsque d'autres opérateurs sont utilisés, les types de base sont convertis en types String avec des caractères, tels que : « 1a », « a1 », sont convertis en NaN, ce qui équivaut à undefined.

Astuce : (1) NaN n'est égal à aucune valeur, y compris elle-même, donc pour déterminer si une valeur est NaN, utilisez "! ==".  

        (2) La conversion en type booléen comme false inclut : null, 0, '', undefined, NaN, false   

        （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中文网其它相关文章！

推荐阅读：

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!