Explication détaillée du mécanisme de conversion implicite des doubles signes égaux (==) en Javascript

Il existe deux façons de juger les relations d'égalité en Javascript : le double signe égal (==) et le triple signe égal (===). Le double signe égal (==) indique l'égalité des valeurs, tandis que le triple signe égal (===) indique l'égalité stricte (si les valeurs et les types sont complètement égaux). Cet article vous présente principalement en détail le mécanisme de conversion implicite du double signe égal (==) en JavaScript. Il est très bon et a une valeur de référence. Les amis qui en ont besoin peuvent s'y référer.

Il y a donc quelques connaissances de bon sens :

1. Pour les types de base tels que la chaîne et le nombre, il y a une différence entre == et ===

1) Entre différents types Comparez, == comparez les "valeurs converties dans le même type" pour voir si les "valeurs" sont égales, === si les types sont différents, le résultat sera inégal

　2) Comparez le même type, exécutez directement "value" "Comparez, les résultats sont les mêmes

2. Pour les types avancés tels que Array et Object, il n'y a pas de différence entre == et ===

Effectuez une comparaison "adresse de pointeur"

3. Il existe une différence entre les types de base et les types avancés, == et ===

　1) Pour ==, convertissez le type avancé en un type de base et effectuez une comparaison de "valeur"

　2 ) Parce que les types sont différents, le résultat === est faux

En d'autres termes, le double signe égal (==) effectuera conversion de type pendant le fonctionnement, mais pas le triple signe égal (===).

Par exemple :

alert('55' == 55); //true
alert('55' === 55); //false

Les cinq types de données de base (valeurs primitives, également appelées types de données simples) dans le langage Javascript : Indéfini, Null, Booléen, Nombre et Chaîne. Étant donné que ces types primitifs occupent une quantité d'espace fixe, ils peuvent être stockés dans une zone de mémoire plus petite : la pile. Un tel stockage facilite la recherche rapide des valeurs des variables ;

Le mécanisme de conversion implicite utilisant le double signe égal (==) en Javascript pour déterminer l'égalité :

1, si les deux côtés sont des types simples :

　1,1, si les deux côtés sont des types simples et que les types sont les mêmes, ils seront comparés directement.

console.log(1==1); //true
console.log("1"=="1"); //true
console.log(false==false); //true
console.log(null==null); //true
console.log(undefined==undefined); //true

1.2. Les deux côtés sont des types simples Si les types sont différents, ils seront d'abord convertis en comparaison numérique (le booléen n'a que deux valeurs : true==1, false==0 ; null et undefined sont égaux ; les caractères Les numéros de chaîne sont égaux aux valeurs numériques, chaîne vide ""==0;)

console.log(1==true); //true
console.log(0==false); //true
console.log(1=="1"); //true
console.log(0==""); //true
console.log(0==null); //false
console.log(0==undefined); //false
console.log(null==undefined); //true

2. Si un côté est un type simple et l'autre côté est un type référence (avancé). type), le type avancé est implicitement converti en types simples et comparés à nouveau.

console.log(Object==Object); //true
console.log(Object=={}); //false
console.log(0=={}); //false
console.log(0==[]); //true
console.log(Array==Array); //true
console.log(Object==Array); //false

3. Si les deux côtés sont des types de référence (types avancés), une comparaison "adresse du pointeur" est effectuée.

Points clés-toString() et valueOf()

La première impression que beaucoup de gens ont en voyant ces deux méthodes est que la méthode toString() convertit un objet en chaîne, et la méthode valueOf La méthode le convertit en chaîne Convertit un objet en valeur numérique.

Cette idée est très unilatérale. Jetons un coup d'œil aux deux exemples suivants :

var obj={
  name:"熊仔其人",
  getName:function(){ return $(this).name; }
};
console.log(obj.toString()); //[object Object]

Définissez un objet obj et appelez sa méthode toString. La valeur de retour est [object Object. ] Discovery ne renvoie pas une représentation sous forme de chaîne de son contenu comme nous le pensions.

var arr=[1,2,3];
console.log(arr.valueOf()); //(3) [1, 2, 3]

Définissez un tableau arr, appelez sa méthode valueOf, la valeur de retour est [1, 2, 3], et constatez qu'il ne renvoie pas de représentation numérique comme nous l'imaginions.

En fait, la vraie compréhension est la suivante : appeler la méthode toString() de l'objet peut convertir l'objet en chaîne, mais si vous souhaitez le convertir en chaîne, vous n'avez pas nécessairement besoin d'appeler toString méthode.

Regardons à nouveau le code ci-dessous.

var obj= { };   
obj.valueOf=function(){ return 1; }
obj.toString=function(){ return 2; }
console.log(obj==1);  //true
var obj2= { };   
obj2.valueOf=function(){ return 2; }
obj2.toString=function(){ return 1; }
console.log(obj2==1);  //false                                      
var obj3={ };
obj3.valueOf=function(){ return []; }
obj3.toString=function(){ return 1; }
console.log(obj3==1);  //true

Dans le code ci-dessus, nous avons défini un objet obj, obj2, et défini les valeurs de retour des méthodes valueOf et toString En les comparant avec 1 pour l'égalité, nous avons constaté que la méthode valueOf. a été appelé en premier.

Définit ensuite un objet obj3, définit la valeur de retour des méthodes valueOf et toString, et la compare avec 1 pour constater qu'il appelle la méthode toString.

Regardons ensuite le morceau de code suivant :

var obj= { };   
obj.valueOf=function(){ return 'a'; }
obj.toString=function(){ return 2; }
console.log(obj=='a');  //true
var obj2= { };   
obj2.valueOf=function(){ return 'b'; }
obj2.toString=function(){ return 'a'; }
console.log(obj2=='a');  //false

Un objet obj est défini dans le code 2 ci-dessus. En le comparant avec la chaîne 'a', on constate que il appelle la méthode valueOf.

Ensuite, la comparaison entre l'objet obj2 et 'a' renvoie false, et on constate que la méthode toString n'est pas appelée.

De là, nous pouvons tirer la conclusion :

Lorsque l'objet est converti en un type simple, la méthode valueOf sera appelée en premier. Si elle peut être comparée à une valeur simple, elle le sera. être comparé directement, et la méthode toString ne sera plus appelée pour le moment. Si la méthode valueOf ne peut pas être comparée à une valeur simple après avoir appelé la méthode valueOf, la méthode toString sera à nouveau appelée pour enfin obtenir le résultat de la comparaison.

Mais une chose à noter est que l'objet Date ne répond pas aux règles ci-dessus. Les méthodes toString et valueOf de l'objet Date ont été redéfinies et la méthode toString sera appelée par défaut.

PS : règles de conversion implicites du double signe égal js

Lors de l'utilisation du double signe égal à des fins de comparaison, lorsque les deux types d'opérandes sont différents, le double signe égal effectuera une conversion implicite Convertir, convertir en le même type, puis comparez. Voici les règles de conversion, qui se trouvent à la page P51 du Petit Livre Rouge. (J'oublie toujours, et j'ai toujours l'impression qu'une bonne mémoire n'est pas aussi bonne qu'une mauvaise écriture. L'écriture a toujours un impact profond)

1. Un opérande est une valeur booléenne. Convertissez la valeur booléenne en valeur numérique. puis comparez-le. False est 0, true est 1.

2 L'un est une chaîne et l'autre est un nombre. Convertissez des chaînes en nombres et comparez-les.

3. Un opérateur est un objet et l'autre n'est pas un objet. Utilisez d'abord valueOf() pour obtenir le type de valeur de l'objet, puis comparez selon d'autres règles.

Recommandations associées :

Exemple de mécanisme de conversion implicite de double signe égal en Javascript

Conversion implicite des types de données Oracle

À propos de quelques conversions implicites et exemples récapitulatifs en JavaScript

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!