Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Operators/Equality below:

Égalité (==) - JavaScript | MDN

Baseline Widely available

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.

console.log(1 == 1);
// Expected output: true

console.log("hello" == "hello");
// Expected output: true

console.log("1" == 1);
// Expected output: true

console.log(0 == false);
// Expected output: true

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.

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

"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

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

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

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

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

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4