Skip to main content

Visit Mozilla.org

Référence de JavaScript 1.5 Core:Opérateurs:Opérateurs de comparaison

Un article de MDC.


Sommaire

[modifier] Résumé

Opérateurs
Implémenté dans : JavaScript 1.0

JavaScript 1.3 : ajout des opérateurs === et !==.

JavaScript 1.4 : l'utilisation de == pour comparer deux objets JSObject est maintenant dépréciée. Utilisez plutôt la méthode JSObject.equals.

Version d'ECMAScript : ECMA-262 comprend tous les opérateurs de comparaison à l'exception de === et !==.

Les opérateurs === and !== font partie de ECMA-262 Edition 3.

Les opérandes peuvent être des valeurs numériques ou des chaînes. Les chaînes sont comparées selon l'ordre lexicographique standard, à l'aide des valeurs Unicode.

Une valeur booléenne est renvoyée comme résultat de la comparaison.

  • Deux chaînes sont égales lorsqu'elles ont la même séquence de caractères, la même longueur et les mêmes caractères aux mêmes positions.
  • Deux nombres sont égaux lorsqu'ils sont numériquement égaux (ont la même valeur numérique). NaN n'est égal à rien, pas même NaN. Les zéros positifs et négatifs sont égaux entre-eux.
  • Deux objets sont égaux s'ils se réfèrent au même Object.
  • Deux opérandes booléens sont égaux s'ils sont tous deux true ou tous deux false.
  • Les types Null et Undefined sont égaux == (mais pas strictement égaux ===).

Le tableau suivant décrit les opérateurs de comparaison :

Opérateur Description Exemples renvoyant true1
Égalité (==) Renvoie true si les opérandes sont égaux. Si les deux opérandes ne sont pas du même type, JavaScript essaie de les convertir en un type approprié pour la comparaison.

3 == var1
"3" == var1
3 == '3'

Inégalité (!=) Renvoie true si les opérandes ne sont pas égaux. Si les deux opérandes ne sont pas du même type, JavaScript essaie de les convertir en un type approprié pour la comparaison.

var1 != 4
var1 != "5"

Égalité stricte (===) Renvoie true si les opérandes sont égaux et du même type.

3 === var1

Inégalité stricte (!==) Renvoie true si les opérandes ne sont pas égaux et/ou d'un type différent.

var2 !== 3
3 !== '3'

Plus grand que (>) Renvoie true si l'opérande de gauche est plus grand que l'opérande de droite.

var2 > var1

Plus grand ou égal (>=) Renvoie true si l'opérande de gauche est plus grand ou égal à l'opérande de droite.

var2 >= var1
var1 >= 3

Plus petit (<) Renvoie true si l'opérande de gauche est plus petit que l'opérande de droite.

var1 < var2

Plus petit ou égal (<=) Renvoie true si l'opérande de gauche est plus petit ou égal à l'opérande de droite.

var1 <= var2
var2 <= 5

1 Ces exemples supposent que l'on a assigné la valeur 3 à var1 et la valeur 4 à var2.

[modifier] Utilisation des opérateurs d'égalité

Les opérateurs d'égalité standard (== et !=) permettent de comparer des opérandes sans tenir compte de leur type. Les opérateurs d'égalité stricte (=== et !==) permettent de comparer des opérandes de même type. Utilisez les opérateurs d'égalité stricte si les opérandes doivent être d'un type particulier en plus d'avoir une valeur particulière, ou si le type exact des opérandes est important. Dans les autres cas, utilisez les opérateurs d'égalité standard, qui permettent de comparer des opérandes même s'ils ne sont pas du même type.

Lorsqu'une conversion de type est nécessaire, JavaScript convertit les objets String, Number, Boolean ou Object de la manière suivante :

  • Lorsqu'un nombre est comparé à une chaîne, la chaîne est convertie en une valeur numérique. JavaScript tente de convertir la valeur numérique littérale de la chaîne en une valeur de type Number. Une valeur mathématique est d'abord dérivée de la chaîne littérale, puis elle est arrondie à la valeur de type Number la plus proche.
  • Si un des opérandes est de type Boolean, il est converti en 1 s'il vaut true, et +0 s'il vaut false.
  • Si un objet est comparé avec un nombre ou une chaîne, JavaScript essaie de renvoyer la valeur par défaut de l'objet. Les opérateurs tentent de convertir l'objet en une valeur primitive, une valeur String ou Number, en utilisant les méthodes valueOf et toString des objets. Si cette tentative de conversion échoue, une erreur d'exécution est générée.

Il n'est pas possible d'utiliser l'opérateur d'égalité standard (==) pour comparer des instances de JSObject. Pour ce faire, utilisez la méthode JSObject.equals.

[modifier] Compatibilité avec les versions antérieures

Le comportement des opérateurs d'égalité standard (== et !=) dépend de la version de JavaScript.

[modifier] JavaScript 1.3 et précédentes

L'opérateur d'égalité standard (==) ou JSObject.equals peuvent tous deux être utilisés pour comparer des instances de JSObject.

[modifier] JavaScript 1.2

Les opérateurs d'égalité standard (== et !=) n'effectuent pas de conversion de type avant de faire la comparaison. Les opérateurs d'égalité stricte (=== et !==) ne sont pas disponibles.

[modifier] JavaScript 1.1 et précédentes

Les opérateurs d'égalité standard (== et !=) effectuent une conversion de type avant de faire la comparaison. Les opérateurs d'égalité stricte (=== et !==) ne sont pas disponibles.

Récupérée de « http://developer.mozilla.org/fr/docs/R%C3%A9f%C3%A9rence_de_JavaScript_1.5_Core:Op%C3%A9rateurs:Op%C3%A9rateurs_de_comparaison »