Valeurs fausses vs chaîne nulle, non définie ou vide

J'ai travaillé avec jQuery au fil des ans. Cependant, récemment, je me suis retrouvé à approfondir le langage JavaScript. Récemment, j'ai entendu parler des valeurs «véridiques» et falsey. Cependant, je ne les comprends pas pleinement. Actuellement, j'ai du code qui ressemble à ceci:

var fields = options.fields || ['id', 'query'];

J'ai besoin d'identifier si les champs sont nuls, non définis ou ont une longueur de 0. Je sais que le long chemin est de faire:

if ((fields === null) || (fields === undefined) || (fields.length === 0)) {
 ...                    
}

Ma question est la suivante:

if (!fields)  {
 ...
}

En programmation, la véracité ou la fausseté est la qualité de ces expressions booléennes qui ne se résolvent pas en une valeur booléenne réelle, mais qui sont néanmoins interprétées comme un résultat booléen.

Dans le cas de C, toute expression évaluée à zéro est interprétée comme fausse. En Javascript, l'expression valuedans

if(value) {
}

évaluera à vrai si valuen'est pas:

null
undefined
NaN
empty string ("")
0
false

Voir aussi
Existe-t-il une fonction standard pour vérifier les variables nulles, non définies ou vides en JavaScript?

L'ensemble des valeurs "truey" et "falsey" en JavaScript provient de l' ToBooleanopération abstraite définie dans la spécification ECMAScript , qui est utilisée lors de la contrainte d'une valeur sur un booléen:

+--------------------------------------------------------------------------+
| Argument Type | Result                                                   |
|---------------+----------------------------------------------------------|
| Undefined     | false                                                    |
|---------------+----------------------------------------------------------|
| Null          | false                                                    |
|---------------+----------------------------------------------------------|
| Boolean       | The result equals the input argument (no conversion).    |
|---------------+----------------------------------------------------------|
| Number        | The result is false if the argument is +0, −0, or NaN;   |
|               | otherwise the result is true.                            |
|---------------+----------------------------------------------------------|
| String        | The result is false if the argument is the empty String  |
|               | (its length is zero); otherwise the result is true.      |
|---------------+----------------------------------------------------------|
| Object        | true                                                     |
+--------------------------------------------------------------------------+

De ce tableau, nous pouvons voir cela nullet undefinedsont tous deux contraints falsedans un contexte booléen. Cependant, votre fields.length === 0ne correspond généralement pas à une fausse valeur. Si fields.lengthest une chaîne, il sera traité comme false(car une chaîne de longueur nulle l'est false), mais s'il s'agit d'un objet (y compris un tableau), il sera contraint true.

Si fieldsdevrait être une chaîne, alors !fieldsest un prédicat suffisant. S'il fieldss'agit d'un tableau, votre meilleure vérification pourrait être:

if (!fields || fields.length === 0)

Réponse courte:

Non , ce ne sont pas les mêmes.

Mais ça:

if (!fields) { ... }

Est la même que celle-ci:

if ((fields === null) || (fields === undefined) || (fields === 0) || (fields === '') || (fields === NaN) || (fields === flase)) { ...
}

Réponse longue (et meilleure):

Parlons d'abord des valeurs véridiques et fausses.

Tout dépend de ce qui se passe lorsque vous évaluez quelque chose en tant que booléen. En JavaScript, cela se produit lorsque vous utilisez des éléments tels que des ifinstructions; opérateurs logiques aiment ||, !ou &&; ou la Boolean()fonction.

La Boolean()fonction accepte une valeur et retourne soit trueou false.

Par exemple:

var age = 1; // Let's evaluate age as a boolean Boolean(age); // true

Allez-y et essayez ceci dans un repl de noeud.

Un booléen ne peut être que trueou false, donc la valeur de retour de Boolean() doit être soit trueou false. Dans ce cas, nous avons transmis la valeur 1et, lorsqu'elle est évaluée comme booléenne, 1est true.

Important: lorsqu'elle est évaluée en tant que booléen, une valeur doit être vraie ou fausse. Ce sont les deux seules options.

En JavaScript, il n'y a que 6 valeurs de falsification. Valeurs qui seront falseévaluées comme booléennes. Ils sont: false, 0, "", null, undefinedet NaN. Donc, si l'une de ces valeurs est évaluée comme un booléen, elle sera fausse:

Boolean(false) // false Boolean(0) // false Boolean("") // false Boolean(null) // false Boolean(undefined) // false Boolean(NaN) // false

Cela signifie que toute autre valeur, en JavaScript, sera trueévaluée en tant que booléen. Donc, toutes les autres valeurs de JavaScript sont véridiques.

Un autre moyen simple d'évaluer quelque chose en tant que tel booleanest d'utiliser l' !opérateur. Tout comme la Booleanfonction, cela évalue une valeur en tant que booléen. Mais les valeurs véridiques deviennent falseet les valeurs fausses deviennent true.

!false // true !0 // true !"" / true !null // true !undefined // true !NaN // true

Encore une fois, essayez ceci dans un nœud repl ou quelque chose pour vous assurer que vous comprenez.

Donc, cette déclaration:

if (!fields) { ... }

Dit ce qui suit: "si fields, lorsqu'il est évalué en tant que booléen, est faux, exécutez le code à l'intérieur de cette instruction if."

Quant à votre première déclaration:

var fields = options.fields || ['id', 'query'];

Vous travaillez avec l'opérateur logique OU, ce qui vaut la peine d'être lu pour vous assurer que vous comprenez. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators

Votre code signifie:

var fields;
if (options.fields)
    fields = options.fields;
else
    fields = ['id', 'query'];

Now options.fieldsest converti en valeur booléenne. Par définition null, undefined, 0, ""est converti en false, ( la plupart du temps) toute autre chose est converti en true(mais je ne veux pas être si précis).

Cela ne veut pas dire la même chose, car la fields.length === 0ligne. Les tableaux vides et autres objets sont convertis en true.

note: Javascript est parfois un gros gâchis ... Par exemple il n'y a pas vraiment besoin de 2 opérateurs de vérification de type (typeof et instanceof). Cela confond simplement ppl lorsqu'il true instanceof Booleanne fonctionne pas et que l'utilisation typeof(true) == "boolean"est sujette aux erreurs en raison de la saisie d'une chaîne sans autocomplétion. Peut-être que dans certaines nouvelles versions, ces problèmes seront résolus.

Vous pouvez essayer (!! champs) si l'élément champs est nul, non défini ou a une longueur de 0, il retournerait vrai. Ou (!!! champs) alors cela retournerait vrai.

le double ! ou !! forcera vrai ou faux. J'aimerais pouvoir trouver une bonne définition pour cela, mais je ne semble pas pouvoir la retrouver.