--- title: Égalité (==) slug: Web/JavaScript/Reference/Operators/Equality tags: - JavaScript - Language feature - Operator - Reference browser-compat: javascript.operators.equality translation-of: Web/JavaScript/Reference/Operators/Equality ---

L'opérateur d'égalité (==) vérifie si ses deux opérandes sont égaux et renvoie un booléen indiquant le résultat de la comparaison. À la différence de l'opérateur d'égalité stricte, l'opérateur d'égalité tente de convertir ses opérandes avant la comparaison si ceux-ci sont de types différents.

{{EmbedInteractiveExample("pages/js/expressions-equality.html")}}

Syntaxe

x == y

Description

Les opérateurs d'égalité (== et !=) utilisent l'algorithme de comparaison d'égalité abstraite pour comparer deux opérandes. On peut le résumer ainsi :

Si les opérandes sont deux objets, on renvoie true uniquement si les deux opérandes référencent le même objet.
Si un opérande vaut null et que l'autre vaut undefined, on renvoie true.
Si les opérandes sont de types différents, on tente une conversion pour avoir le même type de part et d'autre avant la comparaison :
- Si on compare un nombre à une chaîne de caractères, on tentera de convertir la chaîne en une valeur numérique.
- Si l'un des opérandes est un booléen, on le convertira en 1 s'il vaut true et en +0 s'il vaut false.
- Si l'un des opérandes est un objet et que l'autre est un nombre ou une chaîne de caractères, on tentera de convertir l'objet en une valeur primitive grâce aux méthodes valueOf() et toString() de l'objet.
Si les opérandes sont du même types, on les compare comme suit :
- String : on renvoie true uniquement si les deux opérandes ont les mêmes caractères dans le même ordre.
- Number : on renvoie true uniquement si les deux opérandes ont la même valeur. +0 et -0 sont considérés comme la même valeur. Si au moins un des opérandes vaut NaN, on renvoie false.
- Boolean : on renvoie true uniquement si les deux opérandes valent tous les deux true ou s'ils valent tous les deux false.

La différence fondamentale entre cet opérateur et l'opérateur d'égalité stricte (===) est que ce dernier n'opère pas de conversion de type. L'opérateur d'égalité stricte considère toujours que deux valeurs de types différents sont différentes.

Exemples

Comparaison sans conversion de types

1 == 1;              // true
"coucou" == "coucou";  // true

Comparaison avec conversion de types

"1" ==  1;            // true
1 == "1";             // true
0 == false;           // true
0 == null;            // false
0 == undefined;       // false
0 == !!null;          // true, voir la documentation pour !!
0 == !!undefined;     // true, voir la documentation pour !!
null == undefined;    // true

const nombre1 = new Number(3);
const nombre2 = new Number(3);
nombre1 == 3;         // true
nombre1 == nombre2;   // false

Comparaison d'objets

const objet1 = {"clé": "valeur"}
const objet2 = {"clé": "valeur"};

objet1 == objet2 // false
objet2 == objet2 // true

Comparaison entre des chaînes de caractères et des objets String

On notera que les chaînes de caractères construites avec new String() sont des objets. Si on compare une telle valeur avec une chaîne de caractères "primitives", l'objet String sera converti en une chaîne de caractères et les contenus de ces chaînes seront comparés. Toutefois, si les deux opérandes sont des objets String, ils seront comparés comme tels et devront référencer le même objet pour être considérés égaux :

const string1 = "coucou";
const string2 = String("coucou");
const string3 = new String("coucou");
const string4 = new String("coucou");

console.log(string1 == string2); // true
console.log(string1 == string3); // true
console.log(string2 == string3); // true
console.log(string3 == string4); // false
console.log(string4 == string4); // true

Comparaison entre les dates et les chaînes de caractères

const d = new Date('December 17, 1995 03:24:00');
const s = d.toString(); // par exemple : "Sun Dec 17 1995 03:24:00 GMT-0800 (Pacific Standard Time)"
console.log(d == s);    //true