Résumé du jugement dans le code JavaScript

Jugement comparatif

Le jugement de comparaison consiste à comparer deux valeurs et à renvoyer une valeur booléenne pour indiquer si les conditions de comparaison sont remplies. JavaScript fournit un total de 8 opérateurs de comparaison. Ici, nous parlons principalement de la différence entre les opérateurs d'égalité stricts et les opérateurs d'égalité.

Opérateur d'égalité strict ===

 Déterminez que le retour de deux valeurs est différent, faux, les deux valeurs sont null / undefined / true / false true. L'une des deux valeurs est nan, false, les deux valeurs sont numériques et égales, vraies, les deux valeurs sont des chaînes, et les valeurs égales sont vraies, les deux valeurs pointent vers le même type de référence true1 === "1" // falsetrue === true // trueundefined === Undefined // true1 === 1 // truenan === nan // false + 03= -0 // false [] === [] // false (function () {} === function () {}) // falSavar v1 = {}; var v2 = v1; // deux valeurs se réfèrent au même objet v1 === v2 // true

L'opérateur d'égalité strict a un opérateur d'usine strict correspondant (! ==), et les résultats de l'opération des deux sont exactement le contraire.

Opérateur d'égalité ==

 Si l'opérateur d'égalité compare les données du même type, le même opérateur d'égalité strict si l'opérateur d'égalité compare différents types de données: le type d'origine de données sera converti en types numériques, convertit les deux chaînes et les booléens en valeurs numériques, puis comparent l'objet en un type de base non défini et se compare ensuite FAUCE123); // true'123 '== 123; // Vrai, «123» sera converti en valeurs numériques 123false == 0; // Vrai, une fausse conversion en valeurs numériques est 0'a '==' A '; // faux, le codage converti est différent 123 == {}; //false, executing toString() or valueOf() will change 123 == = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = " = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =! // Faux, tant qu'il y a nan, c'est faux {} == {}; // faux, la comparaison est leur adresse. L'adresse de référence de chaque objet nouvellement créé est différent Null == Undefined // true'nan '== nan // false123 == nan // falsenan == nan // falsefalse == 0 // trueTrue == 1 // trueTrue == 2 // falsefined == 0 // FalSenull == 0 // False'123' == 123 // true'123 == 0 // False'123 '== 123 // true'123 == 0 // FAUX'123' == 123 // true'123 == 0 // FAUX'123 '== 123 // Vrai //FAUX

L'opérateur d'égalité a un opérateur inégal correspondant (! =), Et les résultats de l'opération des deux sont exactement le contraire.

!!juge

!! Équivalent à Boolean , il est très utile lors de l'écriture de code !! Le convertir en type Boolean pour le jugement est très utile

 !! 'xzavier'; // vrai!!''; // faux !! '0'; // true !! '1'; // true !! '- 1' // true !! 0 // false !! Undefined // false !! null // false !! nan // false !! {}; // true !! {name: 'xz'} // true !! []; // true !! [1,2,3]; // true !! true; // vrai

!juge

Opérateur inverse! est utilisé pour modifier la valeur booléenne en valeur opposée, c'est-à-dire que vrai devient faux et faux devient vrai. Pour les données qui ne sont pas booléennes, l'opérateur d'inversion les convertit automatiquement en booléen. La règle est que les six valeurs suivantes sont inversées en vrai, et les autres valeurs sont inversées en false

 Undefined null false 0 (y compris +0 et -0) nan vide String ('')! Undefined // true! null // true! false // true! 0 // true! nan // true! "" // true! 54 // false!

[] et {} jugement

Pour [] et {}, nous allons certainement leur porter des jugements dans le code d'entreprise, comme ci-dessus

 !! {}; // true !! {name: 'xz'} // true !! []; // true !! [1,2,3]; // vrai

Je ne peux pas être utilisé pour les jugements! et!. Pour les tableaux, nous utilisons son attribut length au juge

 [] .length // 0 false [1,2,3] .length // 3 true

Pour les objets, vous pouvez utiliser la méthode de jQuery $.isEmptyObject(obj) , ou vous pouvez encapsuler une méthode en imitant jQuery pour écrire un

 fonction isEmpTyObject (obj) {var name; pour (nom dans obj) {return false; } return true;} iSEmpTyObject ({}); // trueiSEmpTyObject ({name: 'xzavier'}); FAUX

Recommander une bibliothèque d'outils underscore , qui a également une méthode isEmpty(object)

 const _ = require ('calendrier'); _. IsEmpty ({}); // vrai

&&juge

Utilisées dans les expressions conditionnelles, les règles sont:

 num1 && num2true vrai vrai vrai vrai faux faux faux faux faux faux faux faux

Utilisé dans une déclaration, les règles sont:

 résultat = expression1 && expression2

Si l'expression1 évalue à False, le résultat est l'expression1. Sinon le résultat est l'expression2

 (1 - 1) && (x + = 1) // 0 (2> 1) && (5 + 5) // 10 (2 + 1) && (5 + 5) // 10

|| jugement

Utilisées dans les expressions conditionnelles, les règles sont:

 num1 || num2true vrai vrai vrai vrai faux faux vrai vrai vrai faux faux faux

Utilisé dans une déclaration, les règles sont:

Si la valeur booléenne du premier opérateur est vraie, la valeur du premier opérateur est renvoyée et le deuxième opérateur n'est plus évalué.

Si la valeur booléenne du premier opérateur est fausse, la valeur du deuxième opérateur est renvoyée

|| Les opérateurs effectuent généralement un traitement de jugement d'expression conditionnel et de la tolérance aux défauts dans le code commercial. Si nous ne pouvons pas obtenir les données lors de la récupération, elle ne peut pas affecter le code commercial ultérieur, nous devons donc être une tolérance aux pannes. || est une très bonne méthode d'écriture tolérante aux pannes, ce qui équivaut à fournir des données de sauvegarde.

 Var Data = Undefined || backup_data; // Lorsqu'il y a une erreur dans la demande et que les données ne sont pas définies, accédez à BACKUP DONNE BACKUP_DATA

Jugement à trois yeux

règle:

 condition ? Expression1: Expression2; fonction ABSN (xzavier) {return xzavier> 0? xzavier: -xzavier;} absn (-123); // 123ABSN (123); // 123

Si la valeur booléenne de la première expression est vraie, la valeur de la deuxième expression est renvoyée, sinon la valeur de la troisième expression est renvoyée.

Résumer

Ce qui précède est tout le contenu du jugement dans le code JavaScript pour tout le monde. J'espère que le contenu de cet article sera utile à tous ceux qui utilisent JavaScript.