Démêler le '===' de javascript

Ce guide se plonge dans les subtilités de l'opérateur d'égalité strict de JavaScript (===), tel que défini dans la section "Comparaison stricte" stricte d'égalité de la spécification ECMAScript. Explorons sa fonctionnalité étape par étape:

l'algorithme ===: un look détaillé

L'opérateur === utilise l'algorithme suivant pour déterminer l'égalité:

1. Vérification de type: L'opérateur compare d'abord les types des deux valeurs. Si les types diffèrent, il renvoie immédiatement false. Le type correspondant à l'étape suivante uniquement si les types sont identiques.

2. Comparaison spécifique au type:

   • Nombres:

     • NaN === NaN évalue à false (un point crucial de divergence).
     • Les valeurs identiques numériques renvoient true.
     • 0 et -0 sont considérés comme égaux (true).

   • chaînes: La comparaison caractéristique par caractère détermine l'égalité. Les séquences identiques rendent true; Sinon, false.

   • booléens: true === true et false === false Les deux renvoient true. Sinon, false.

   • Objets (tableaux et fonctions inclus): === Vérifies pour Égalité de référence . Seulement si les deux valeurs pointent vers le même emplacement de mémoire (le même objet) qu'il renvoie true.

   • null et undefined: null === null et undefined === undefined return true. Cependant, null === undefined est false en raison des différences de type.

---

Pourquoi NaN === NaN est false

Il s'agit d'une source de confusion fréquente. La spécification définit NaN (pas-un nombre) comme inégale pour elle-même. En effet, NaN représente un résultat numérique non valide ou non défini; Comparaison de deux résultats indéfinis en égale manque de cohérence logique.

Exemple:

NaN === NaN; // false

pour vérifier de manière fiable NaN, utiliser Number.isNaN() ou Object.is():

Number.isNaN(NaN); // true
Object.is(NaN, NaN); // true

---

Pourquoi 0 === -0 est true

La spécification traite 0 et -0 comme équivalent car, dans la plupart des opérations mathématiques, leur comportement est indiscernable. Cependant, des différences subtiles existent dans des scénarios spécifiques (par exemple, 1 / 0 donne Infinity, tandis que 1 / -0 entraîne -Infinity). Pour les situations nécessitant une différenciation, utilisez Object.is():

NaN === NaN; // false

---

objets et égalité de référence (revisité)

Lors de la comparaison des objets, === évalue l'égalité de référence . Deux objets avec des contenus identiques ne sont pas considérés comme égaux à moins qu'ils ne soient le même objet en mémoire:

Number.isNaN(NaN); // true
Object.is(NaN, NaN); // true

mais:

Object.is(+0, -0); // false

Exploration plus approfondie des principes fondamentaux JavaScript

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!