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:

<code class="language-javascript">NaN === NaN; // false</code>

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

<code class="language-javascript">Number.isNaN(NaN); // true
Object.is(NaN, NaN); // true</code>

---

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():

<code class="language-javascript">NaN === NaN; // false</code>

---

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:

<code class="language-javascript">Number.isNaN(NaN); // true
Object.is(NaN, NaN); // true</code>

mais:

<code class="language-javascript">Object.is(+0, -0); // false</code>

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!