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

Il existe deux types de signes 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).

Il y a donc quelques connaissances de bon sens :

1 Pour les types de base tels que string, number, etc., il y a une différence entre ==. et ===
1) Comparaison entre différents types, == compare les "valeurs converties dans le même type" pour voir si les "valeurs" sont égales, === si les types sont différents, le résultat est inégal
2) Comparaison du même type, comparez directement "valeur", le résultat est le même

2. Pour les types avancés tels que Array, Object, == et === sont indiscernables
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 type de base et effectuez Comparaison "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, tandis que le triple signe égal (== =) No.

Par exemple :

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

Les cinq types de données de base en langage Javascript (valeurs originales, également appelées types de données simples ) : C'est-à-dire Type non défini, nul, booléen, numérique 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. Ce stockage permet de rechercher facilement et rapidement la valeur de la variable. (Pour plus de détails, voir : http://www.w3school.com.cn/js/pro_js_value.asp)

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, les deux côtés sont des types simples et les types sont les mêmes, alors comparez 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 ; StringLe nombre est égal à la valeur numérique, 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 de référence (type avancé), puis les types avancés sont implicitement convertis en types simples avant comparaison.

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 et appelez sa méthode valueOf. La valeur de retour est [1, 2, 3]. Nous constatons que le type numérique n'est pas renvoyé comme nous l'imaginions. exprimer.

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);    //truevar 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');    //truevar 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 sera comparée directement. La méthode toString n'est 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.

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!