web-dev-qa-db-fra.com

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 complètement. 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)  {
 ...
}
javascript
11
user687554

Dans la programmation, la véracité ou la fausseté est la qualité de ces expressions booléennes qui ne se résolvent pas à 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 value dans

if(value) {
}

sera évalué à vrai si value n'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?

23
Robert Harvey

L'ensemble des valeurs "truey" et "falsey" en JavaScript provient de l'opération abstraite ToBoolean définie dans la spécification ECMAScript , qui est utilisée lors de la contrainte d'une valeur en 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                                                     |
+--------------------------------------------------------------------------+

Dans ce tableau, nous pouvons voir que null et undefined sont tous deux contraints à false dans un contexte booléen. Cependant, votre fields.length === 0 ne correspond généralement pas à une fausse valeur. Si fields.length est une chaîne, alors elle sera traitée comme false (car une chaîne de longueur nulle est false), mais si c'est un objet (y compris un tableau), il sera contraint à true.

Si fields doit être une chaîne, alors !fields est un prédicat suffisant. Si fields est un tableau, votre meilleure vérification pourrait être:

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

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 les instructions if; des opérateurs logiques comme ||, ! ou &&; ou la fonction Boolean().

La fonction Boolean() accepte une valeur et renvoie true ou 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 true ou false, donc la valeur de retour de Boolean() doit soit true ou false. Dans ce cas, nous avons passé la valeur 1, Et lorsqu'il est évalué comme un booléen, 1 Est 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 lorsqu'elles seront évaluées comme un booléen. Ce sont: false, 0, "", null, undefined et 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 lorsqu'elle sera évaluée comme booléenne. Donc, toutes les autres valeurs de JavaScript sont véridiques.

Un autre moyen simple d'évaluer quelque chose en tant que boolean est d'utiliser l'opérateur !. Tout comme la fonction Boolean, cela évalue une valeur en tant que booléen. Mais les valeurs véridiques deviennent false et les valeurs fausses deviennent true.

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

Encore une fois, essayez ceci dans un repl de noeud 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é comme un 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 OR, qui vaut la peine d'être lu pour vous assurer que vous comprenez. https://developer.mozilla.org/en-US/docs/ Web/JavaScript/Référence/Opérateurs/Opérateurs_logiques

2
Sam

Votre code signifie:

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

Maintenant options.fields Est converti en valeur booléenne. Par définition null, undefined, 0, "" Est converti en false, (surtout) tout le reste est converti en true (mais je ne veux pas être aussi précis).

Cela ne signifie pas la même chose, car la ligne fields.length === 0. 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 lorsque true instanceof Boolean ne fonctionne pas et utilise typeof(true) == "boolean" est sujet 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.

0
inf3rno