'
Articles

Comparaisons

author
7 minutes, 7 seconds Read

Nous connaissons de nombreux opérateurs de comparaison grâce aux maths.

En JavaScript, ils s’écrivent comme suit :

  • Plus grand/moins grand que : a > b, a < b.
  • Supérieur/moins que ou égal : a >= b, a <= b.
  • Egale : a == b, veuillez noter que le double signe d’égalité == signifie le test d’égalité, tandis qu’un seul a = b signifie une affectation.
  • Non égaux. En mathématiques, la notation est ≠, mais en JavaScript, elle s’écrit a != b.

Dans cet article, nous en apprendrons plus sur les différents types de comparaisons, comment JavaScript les effectue, y compris les particularités importantes.

À la fin, vous trouverez une bonne recette pour éviter les problèmes liés aux « bizarreries JavaScript ».

Le booléen est le résultat

Tous les opérateurs de comparaison renvoient une valeur booléenne :

  • true – signifie « oui », « correct » ou « la vérité ».
  • false – signifie « non », « faux » ou « pas la vérité ».

Par exemple :

alert( 2 > 1 ); // true (correct)alert( 2 == 1 ); // false (wrong)alert( 2 != 1 ); // true (correct)

Un résultat de comparaison peut être affecté à une variable, comme toute valeur :

let result = 5 > 4; // assign the result of the comparisonalert( result ); // true

Comparaison de chaînes de caractères

Pour savoir si une chaîne de caractères est supérieure à une autre, JavaScript utilise l’ordre dit « dictionnaire » ou « lexicographique ».

En d’autres termes, les chaînes de caractères sont comparées lettre par lettre.

Par exemple :

alert( 'Z' > 'A' ); // truealert( 'Glow' > 'Glee' ); // truealert( 'Bee' > 'Be' ); // true

L’algorithme pour comparer deux chaînes de caractères est simple :

  1. Comparer le premier caractère des deux chaînes de caractères.
  2. Si le premier caractère de la première chaîne est supérieur (ou inférieur) à celui de l’autre chaîne, alors la première chaîne est supérieure (ou inférieure) à la seconde. Nous avons terminé.
  3. Au contraire, si les premiers caractères des deux chaînes sont les mêmes, comparez les seconds caractères de la même façon.
  4. Répétez jusqu’à la fin de l’une ou l’autre des chaînes.
  5. Si les deux chaînes se terminent à la même longueur, alors elles sont égales. Sinon, la chaîne la plus longue est plus grande.

Dans le premier exemple ci-dessus, la comparaison 'Z' > 'A' arrive à un résultat dès la première étape.

La deuxième comparaison 'Glow' et 'Glee' nécessite plus d’étapes car les chaînes de caractères sont comparées caractère par caractère:

  1. G est identique à G.
  2. l est identique à l.
  3. o est supérieure à e. Arrêtez-vous ici. La première chaîne est plus grande.

Pas un vrai dictionnaire, mais un ordre Unicode

L’algorithme de comparaison donné ci-dessus est à peu près équivalent à celui utilisé dans les dictionnaires ou les annuaires téléphoniques, mais ce n’est pas exactement le même.

Par exemple, la casse compte. Une lettre majuscule "A" n’est pas égale à la minuscule "a". Laquelle est la plus grande ? La minuscule "a". Pourquoi ? Parce que le caractère minuscule a un indice plus grand dans la table d’encodage interne que JavaScript utilise (Unicode). Nous reviendrons sur les détails spécifiques et les conséquences de ceci dans le chapitre Strings.

Comparaison de différents types

Lorsque l’on compare des valeurs de différents types, JavaScript convertit les valeurs en nombres.

Par exemple :

alert( '2' > 1 ); // true, string '2' becomes a number 2alert( '01' == 1 ); // true, string '01' becomes a number 1

Pour les valeurs booléennes, true devient 1 et false devient 0.

Par exemple :

alert( true == 1 ); // truealert( false == 0 ); // true

Une conséquence amusante

Il est possible qu’au même moment :

  • Deux valeurs soient égales.
  • L’une d’elles est true en tant que booléen et l’autre est false en tant que booléen.

Par exemple :

let a = 0;alert( Boolean(a) ); // falselet b = "0";alert( Boolean(b) ); // truealert(a == b); // true!

Du point de vue de JavaScript, ce résultat est tout à fait normal. Un contrôle d’égalité convertit les valeurs en utilisant la conversion numérique (donc "0" devient 0), alors que la conversion explicite Boolean utilise un autre ensemble de règles.

Egalité stricte

Un contrôle d’égalité régulier == a un problème. Il ne peut pas différencier 0 de false:

alert( 0 == false ); // true

La même chose se produit avec une chaîne vide :

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

Cela se produit parce que les opérandes de types différents sont convertis en nombres par l’opérateur d’égalité ==. Une chaîne vide, tout comme false, devient un zéro.

Que faire si l’on souhaite différencier 0 de false?

Un opérateur d’égalité stricte === vérifie l’égalité sans conversion de type.

En d’autres termes, si a et b sont de types différents, alors a === b renvoie immédiatement false sans tentative de conversion.

Essayons-le :

alert( 0 === false ); // false, because the types are different

Il existe également un opérateur de « non-égalité stricte » !== analogue à !=.

L’opérateur d’égalité stricte est un peu plus long à écrire, mais rend évident ce qui se passe et laisse moins de place aux erreurs.

Comparaison avec null et undefined

Il y a un comportement non intuitif lorsque null ou undefined sont comparés à d’autres valeurs.

Pour une vérification stricte de l’égalité ===

Ces valeurs sont différentes, car chacune d’entre elles est un type différent.

alert( null === undefined ); // false

Pour une vérification non stricte ==

Il y a une règle spéciale. Ces deux-là forment un « doux couple » : ils s’égalent l’un l’autre (au sens de ==), mais pas n’importe quelle autre valeur.

alert( null == undefined ); // true

Pour les maths et autres comparaisons < > <= >=

null/undefined sont convertis en nombres : null devient 0, tandis que undefined devient NaN.

Voyons maintenant les choses amusantes qui se produisent lorsque nous appliquons ces règles. Et, ce qui est plus important, comment ne pas tomber dans un piège avec elles.

Résultat étrange : null vs 0

Comparons null avec un zéro:

alert( null > 0 ); // (1) falsealert( null == 0 ); // (2) falsealert( null >= 0 ); // (3) true

Mathématiquement, c’est étrange. Le dernier résultat indique que « null est supérieur ou égal à zéro », donc dans l’une des comparaisons ci-dessus, ce doit être true, mais elles sont toutes deux fausses.

La raison est qu’un contrôle d’égalité == et les comparaisons > < >= <= fonctionnent différemment. Les comparaisons convertissent null en un nombre, en le traitant comme 0. C’est pourquoi (3) null >= 0 est vrai et (1) null > 0 est faux.

En revanche, le contrôle d’égalité == pour undefined et null est défini de telle sorte que, sans aucune conversion, ils sont égaux entre eux et n’égalent rien d’autre. C’est pourquoi (2) null == 0 est faux.

Un indéfini incomparable

La valeur undefined ne devrait pas être comparée à d’autres valeurs:

alert( undefined > 0 ); // false (1)alert( undefined < 0 ); // false (2)alert( undefined == 0 ); // false (3)

Pourquoi le zéro lui déplaît-il tant ? Toujours faux !

Nous obtenons ces résultats parce que :

  • Les comparaisons (1) et (2) renvoient false car undefined est converti en NaN et NaN est une valeur numérique spéciale qui renvoie false pour toutes les comparaisons.
  • Le contrôle d’égalité (3) renvoie false parce que undefined n’est égal qu’à null, undefined, et à aucune autre valeur.

Éviter les problèmes

Pourquoi avons-nous revu ces exemples ? Devrions-nous nous souvenir de ces particularités en permanence ? Eh bien, pas vraiment. En fait, ces choses délicates deviendront progressivement familières avec le temps, mais il y a une façon solide d’éviter les problèmes avec elles :

  • Traiter toute comparaison avec undefined/null, sauf l’égalité stricte ===, avec un soin exceptionnel.
  • Ne pas utiliser les comparaisons >= > < <= avec une variable qui peut être null/undefined, sauf si vous êtes vraiment sûr de ce que vous faites. Si une variable peut avoir ces valeurs, vérifiez-les séparément.

Summary

  • Les opérateurs de comparaison retournent une valeur booléenne.
  • Les chaînes de caractères sont comparées lettre par lettre dans l’ordre du « dictionnaire ».
  • Lorsque des valeurs de types différents sont comparées, elles sont converties en nombres (à l’exclusion d’une vérification stricte de l’égalité).
  • Les valeurs null et undefined sont égales == entre elles et ne sont égales à aucune autre valeur.
  • Soyez prudent lorsque vous utilisez des comparaisons comme > ou < avec des variables qui peuvent occasionnellement être null/undefined. Vérifier les null/undefined séparément est une bonne idée.

Similar Posts

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.