Valeurs de vérité et de fausseté: quand tout n'est pas égal en javascript

Les comparaisons d'égalité de JavaScript peuvent être délicates en raison de sa frappe lâche. Cet article explore les nuances des opérateurs doubles (==) et triples (===), et le concept de valeurs de vérité et de fausseté.

Comprendre ces concepts conduit à un code plus propre et plus prévisible.

Prise des clés:

• Le typage dynamique de JavaScript permet des affectations de valeur flexibles mais peut provoquer des résultats de comparaison inattendus. L'égalité lâche (==) effectue une coercition de type, conduisant souvent à des résultats surprenants. L'égalité stricte (===) compare directement les valeurs et les types, résultant en des comparaisons plus fiables.
• Chaque valeur JavaScript est soit la vérité ou la fausseté. Les valeurs de fausseté sont false, 0, -0, 0n, "", null, undefined, et NaN. Toutes les autres valeurs sont la vérité, y compris '0', 'false', [], {}, et fonctionnent.
• Les comparaisons d'égalité en vrac avec les valeurs de vérité / faussesse peuvent être imprévisibles. Par exemple, false == 0 == '' est vrai, mais [] == true est faux, et [] == false est vrai! L'égalité stricte évite ces ambiguïtés.
• Pour éviter les erreurs, évitez les comparaisons directes de vérité / faussesse. Utilisez une égalité stricte (===) et convertissez explicitement en valeurs booléennes (Boolean() ou !!) lorsque cela est nécessaire. Cela garantit un comportement prévisible.

Système de frappe de JavaScript:

Les variables JavaScript sont dactylographiées:

<code class="language-javascript">let x;
x = 1;   // x is a number
x = '1'; // x is a string
x = [1]; // x is an array</code>

L'égalité lâche (==) convertit les valeurs en chaînes avant la comparaison:

<code class="language-javascript">// all true
1 == '1';
1 == [1];
'1' == [1];</code>

Égalité stricte (===) considère le type:

<code class="language-javascript">// all false
1 === '1';
1 === [1];
'1' === [1];</code>

Les types primitifs de JavaScript sont: undefined, null, boolean, number, bigint, string, et symbol. Tout le reste est un objet (y compris les tableaux).

Values ​​Vérité vs Falsy:

Chaque valeur a un équivalent booléen:

• Falsy: false, 0, -0, 0n, "", null, undefined, NaN
• vérité: tout le reste.

Exemple:

<code class="language-javascript">if (value) {
  // value is truthy
} else {
  // value is falsy
}</code>

document.all (déprécié) est également fausse.

Comparaisons de l'égalité lâche (==):

L'égalité lâche conduit à des résultats inattendus avec des valeurs de vérité / fausses:

Égalité stricte (===) Comparaisons:

L'égalité stricte fournit des résultats plus clairs:

Notez que NaN === NaN est toujours false.

Recommandations:

1. Évitez les comparaisons directes: Utiliser !x au lieu de x == false.
2. Utiliser une égalité stricte (===): fournit des résultats plus prévisibles.
3. Convertir en booléen: utiliser Boolean(x) ou !!x pour la conversion booléenne explicite.

Conclusion:

Comprendre les valeurs de vérité / falsie et l'utilisation de l'égalité stricte améliore la fiabilité du code. Évitez les pièges des comparaisons lâches pour éviter les maux de tête de débogage.

FAQS (abrégé pour la brièveté):

• Concept de vérité / fausseté: Valeurs traitées comme vraies / fausses dans les contextes booléens.
• Manipulation de JavaScript: Type La coercition convertit les valeurs en booléen.
• Exemples: Voir les listes ci-dessus.
• Vérifier la vérité / fausseté: Utiliser dans des contextes booléens ou Boolean() fonction.
• == vs ===: Loose vs égalité stricte; === évite la coercition de type.
• Évaluation des expressions: court-circuit en logique et (&&) et ou (||).
• VALEURS DE FALSY NON-BOOLÉAN: 0, "", null, undefined, NaN, -0.
• Conversion en booléen: utiliser Boolean().
• Valeurs de falsification dans les opérations logiques: affecter les résultats de l'opération.
• Cas spéciaux: 0 vs '0', les tableaux / objets vides sont la vérité.

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!