Pendant le processus d'application JavaScript, nous rencontrerons diverses comparaisons. Aujourd'hui, j'ai compilé trois situations pour vous et les apprendre ensemble.
1. Comparaison de deux objets
Les comparaisons JavaScript sont mélangées avec des fonctionnalités étranges, jetons un coup d'œil à quelques comparaisons simples.
// Comparaison des valeurs brutes> var a = 12UnDefined> var b = 12UndEfined> a == btrue> a === btrue // Comparaison des objets> var c = [] Undefined> var d = [] Undefined> C == dfalse> c === dfalse
D'après les résultats ci-dessus, nous pouvons voir que la comparaison de deux valeurs d'origine semble être un peu différente de la comparaison des objets. Si vous comparez les valeurs de deux objets, même si leurs valeurs sont les mêmes, le résultat final est différent. Lors de la comparaison de deux objets, les références des deux objets doivent être comparées.
Si nous faisons ceci:
> var m = {} Undefined> n = m {}> n === mtrueCela signifie que les deux variables pointent vers le même objet, donc elles sont les mêmes.
2. Comparaison de différents types
Il y a aussi la situation spéciale suivante
> 12 == "12" true> null == UndefinedTrue> Undefined == falsefalse> null == falsefalse> null === undefinedfalse
Pourquoi les entiers peuvent-ils être égaux aux chaînes? En effet, == (égal à, pas congruent) ne compare pas les types. Avant de comparer, il tapera les valeurs qui doivent être comparées. Ici, la chaîne sera convertie en types numériques puis comparée . Pourquoi est-ce si sûr? Faisons quelques expériences.
> 1 + 23> 1 + "2" '12'> 2 <"12" true> "2" <"12" false
D'après l'exemple ci-dessus, nous pouvons voir que la valeur 2 est en effet inférieure à la chaîne 12. Si la comparaison a été convertie en une chaîne avant que la valeur ne soit convertie en chaîne, le résultat doit être "2"> "12".
Vous ne le croyez pas encore? Permettez-moi de vous donner un autre exemple.
> "12d"> 12false> "12d" <12false> "12d" == 12false> "12" <"12d" True
Pourquoi est-ce? Si vous convertissez 12 en une chaîne, alors 12D devrait être supérieur à 12, non? Pourquoi le comparez-vous à False? Je suppose que c'est à cause du gars spécial ci-dessous.
> Nan <1false> nan> 1false
Peu importe ce que NAN se compare, il reviendra faux. Y compris lui-même. Par conséquent, la meilleure façon de déterminer si une variable est nan est x! = X Si le renvoyé est vrai, cela signifie que x est nan . Ensuite, ceci devrait être lorsque 12D doit être converti en type numérique car il a des caractères spéciaux et devient enfin nan. Peu importe comment vous le comparez avec le type numérique, le résultat est faux.
Pour les opérateurs numériques et chaînes, l'opérateur de signe plus se comporte différemment de l'opérateur de comparaison. L'opérateur plus préfère les chaînes, et si l'un des opérandes est une chaîne, il sera converti en chaîne. Les opérateurs de comparaison préfèrent les nombres et les comparaisons de chaînes ne seront effectuées que lorsque les deux nombres sont des chaînes.
Quant aux nuls et non définis ci-dessus. . . . . Je ne sais pas comment expliquer leur comportement pour le moment. Je ne m'en souviens que pour l'instant. Parce qu'ils sont spéciaux.
3. Comparaison des objets avec des valeurs d'origine
Si deux objets qui doivent être comparés sont des objets JavaScript et des squelettes, un certain degré de conversion de type sera effectué. Trouvez un moyen de convertir la valeur de l'objet en valeur d'origine. D'une manière générale, il existe deux méthodes valueOf, toString . Voici le processus de conversion d'un objet vide:
// Je l'ai écrit directement> a = {} {} // 1. Valeurof Conversion> a.valueof () {} // 2. Si l'opération ci-dessus se traduit par une valeur brute, utilisez toString pour convertir. (Et vice versa)> a.toString () '[objet objet]'> a == '[objet objet]' true Ce qui précède est en fait un processus de conversion d'objet intégré et un mécanisme JavaScript. Il appellera d'abord valueOf de la conversion. Si la valeur obtenue n'est pas une valeur primitive, elle appellera alors toString pour la conversion. La valeur finale est '[object Object]' une valeur très étrange, mais c'est la valeur d'origine. Si la variable A et cette valeur sont égales (pas congruentes), un vrai résultat peut être obtenu. (Cela s'est-il effondré?)
Cependant, le guide faisant autorité donne les principes suivants, nous pouvons nous y référer.
Convertir les valeurs brutes JavaScript Language Core intégrées Classes Essayez d'abord de convertir avec ValueO F, puis utilisez toString pour la conversion. À l'exception de la classe de date, il n'utilise que toString pour la conversion. Les objets qui ne sont pas au cœur de JavaScript sont convertis en valeurs d'origine à travers la façon dont elles sont définies dans leurs implémentations respectives.
Selon l'explication ci-dessus. Lorsque nous comparons A = {} avec la valeur d'origine, nous appellerons d'abord la valueOf la valeur de la valeur, et le résultat est que {} n'est évidemment pas une valeur primitive. Ensuite, la conversion sera effectuée à l'aide toString . Enfin, cet étrange résultat est sorti. Mais cet étrange résultat '[object Object]' est en effet la valeur d'origine de {}. (C'est le littéral d'une chaîne).
Ce qui précède est un résumé comparatif en JavaScript. J'espère que la description de cet article sera utile à tout le monde lors de l'apprentissage de JavaScript.