Égalité stricte vs faible

Fait partie de la section Fondamentaux du Journey JavaScript de Coddy — leçon 16 sur 77.

En JavaScript, il existe deux types d'opérateurs d'égalité : l'égalité faible (==) et l'égalité stricte (===).

L'égalité faible (==) vérifie si deux valeurs sont égales après avoir effectué une coercition de type. Cela signifie que si les opérandes ont des types différents, JavaScript tentera de les convertir en un type commun avant d'effectuer la comparaison.

Par exemple :

let b = 5 == "5";   // Vaut true, car la chaîne "5" est convertie en nombre 5 avant la comparaison

let b = 0 == false; // Vaut true, car le booléen false est converti en nombre 0 avant la comparaison

L'égalité stricte (===), en revanche, vérifie si deux valeurs sont égales sans effectuer de conversion de type. Si les opérandes ont des types différents, ils sont considérés comme non égaux.

Par exemple :

let b = 5 === "5";   // Contient false, car aucune conversion de type n'est effectuée, et un nombre n'est pas égal à une chaîne de caractères

let b = 0 === false; // Contient false, car aucune conversion de type n'est effectuée, et le nombre 0 n'est pas égal au booléen false

En général, il est recommandé d'utiliser l'égalité stricte (===) dans la plupart des cas pour éviter des résultats inattendus dus à la coercition de type.

De même, il existe également des opérateurs d'inégalité large (!=) et d'inégalité stricte (!==) qui fonctionnent de manière similaire, mais vérifient l'inégalité au lieu de l'égalité.

L'inégalité non stricte (!=) vérifie si deux valeurs ne sont pas égales après avoir effectué une coercition de type, tandis que l'inégalité stricte (!==) vérifie si deux valeurs ne sont pas égales sans effectuer de conversion de type.

Défi

Débutant

On vous donne un code avec trois variables : a, b et c.

Votre tâche consiste à effectuer les comparaisons suivantes et à afficher les résultats :

Vérifiez si a est lâchement égal à b et stockez le résultat dans d.
Vérifiez si a est strictement égal à c et stockez le résultat dans e.
Vérifiez si b est lâchement non égal à c et stockez le résultat dans f.
Vérifiez si a est strictement non égal à b et stockez le résultat dans g.

Utilisez les variables et les opérateurs de comparaison fournis pour accomplir la tâche.

Aide-mémoire

JavaScript possède deux types d'opérateurs d'égalité :

L'égalité faible (==) effectue une coercition de type avant la comparaison :

5 == "5"   // true - la chaîne "5" est convertie en nombre 5
0 == false // true - le booléen false est converti en nombre 0

L'égalité stricte (===) compare sans conversion de type :

5 === "5"   // false - nombre vs chaîne, pas de conversion
0 === false // false - nombre vs booléen, pas de conversion

De même pour les opérateurs d'inégalité :

Inégalité faible (!=) - effectue une coercition de type
Inégalité stricte (!==) - pas de conversion de type

Il est recommandé d'utiliser l'égalité stricte (===) pour éviter des résultats inattendus dus à la coercition de type.

Essayez vous-même

// Variables fournies
let a = 10
let b = "10"
let c = true

// Tapez votre code ci-dessous


// Ne modifiez pas la ligne ci-dessous
console.log(`d = ${d}`)
console.log(`e = ${e}`)
console.log(`f = ${f}`)
console.log(`g = ${g}`)