Explication des connaissances sur la conversion implicite js (avec exemples)

Cet article vous apporte des connaissances sur la conversion implicite js (avec des exemples). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Apéritifs

[] == ![]                  //true  ==> "" == false
123 ^ []                   //123   ==> 123 ^ 0
~{}                        //-1    ==> ~0
{} >= {1,2}                //true  ==>因为大于等于的比较，不是相等的比较，所以[object Object] >=[object Object]
[null] == ""               //true  ==> [""] == ""

Opérateurs notables :

• Opérateurs unaires : Conversion via Nombre(); by Number()

+undefined   //NaN

• Opérateurs logiques : ! Equivalent de Boolean(), l'opération de conversion de type booléen des nombres

• opérations sur les bits : ~, |, &, ^ ; Lorsqu'un opérande est NaN, cela équivaut à ce que l'opérande soit 0 ; >Opérateur Plus, plus complexe

//由以下变化可以证得：
NaN ^ NaN ^ NaN = 0

La priorité la plus élevée est la chaîne, tout opérande est différent de la chaîne Ajoutez la chaîne (x) dans une chaîne, puis effectuez une concaténation de chaîne

• suivi d'un nombre, et l'objet génère le type de chaîne dans des circonstances normales

Lorsqu'une partie est booléenne, ou que les deux parties sont booléennes, elles seront traitées comme un nombre. Il en va de même pour. undefined et null

console.log("a" + 1);           //"a1"
console.log("a" + "1");         //"a1"
console.log("a" + false);       //"afalse"
console.log("a" + undefined);   //"aundefined"
console.log("a" + NaN);         //"aNaN"
console.log("a" + null);        //"anull"
console.log("a" + {});          //"a[object Object]"

signe moins, alors les deux côtés seront traités Number() gère les opérations de comparaison

//console.log(1 + "1");     //"11"
console.log(1 + 1);         //2
console.log(1 + true);      //2 
console.log(1 + undefined); //NaN
console.log(1 + NaN);       //NaN
console.log(1 + null);      //1
console.log(1 + {});        //"1[object,Object]"

console.log(true + true);      //2 
console.log(true + undefined); //NaN
console.log(true + NaN);       //NaN
console.log(true + null);      //1
console.log((true + [NaN]));   //"trueNaN"

 : == , >, <, >=, >=, != Suivez les règles (extraites de Elevation 3) :

• 1 null et indéfini sont égaux

  2. pour l'égalité, null et non défini ne peuvent être convertis en aucune autre valeur
3 Si un opérande est NaN, l'opérateur d'égalité renvoie fasle, l'opérateur d'inégalité renvoie vrai, NaN n'est pas égal à NaN
• 4. objets, les deux pointent vers le même objet (même adresse), l'opérateur d'égalité renvoie vrai, sinon il renvoie faux

  valeur Notez que les méthodes de comparaison de >= et ==(!=) entre les objets sont différentes. est une comparaison de la valeur de retour de toString(), et cette dernière est une comparaison d'adresses de référence

  Lorsque les deux côtés sont une chaîne de caractères, comparez en fonction de la taille d'encodage des caractères
Quand un opérande est booléen, chaîne, objet, convertissez-le en une valeur de type numérique puis comparez ;

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!