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) {
...
}
javascript
user687554
la source
la source
Réponses:
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
value
dansévaluera à vrai si
value
n'est pas:Voir aussi
Existe-t-il une fonction standard pour vérifier les variables nulles, non définies ou vides en JavaScript?
la source
L'ensemble des valeurs "truey" et "falsey" en JavaScript provient de l'
ToBoolean
opération abstraite définie dans la spécification ECMAScript , qui est utilisée lors de la contrainte d'une valeur sur un booléen:De ce tableau, nous pouvons voir cela
null
etundefined
sont tous deux contraintsfalse
dans un contexte booléen. Cependant, votrefields.length === 0
ne correspond généralement pas à une fausse valeur. Sifields.length
est une chaîne, il sera traité commefalse
(car une chaîne de longueur nulle l'estfalse
), mais s'il s'agit d'un objet (y compris un tableau), il sera contrainttrue
.Si
fields
devrait être une chaîne, alors!fields
est un prédicat suffisant. S'ilfields
s'agit d'un tableau, votre meilleure vérification pourrait être:la source
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
if
instructions; opérateurs logiques aiment||
,!
ou&&
; ou laBoolean()
fonction.La
Boolean()
fonction accepte une valeur et retourne soittrue
oufalse
.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
oufalse
, donc la valeur de retour deBoolean()
doit être soittrue
oufalse
. Dans ce cas, nous avons transmis la valeur1
et, lorsqu'elle est évaluée comme booléenne,1
esttrue
.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
,undefined
etNaN
. 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
boolean
est d'utiliser l'!
opérateur. Tout comme laBoolean
fonction, cela évalue une valeur en tant que booléen. Mais les valeurs véridiques deviennentfalse
et les valeurs fausses deviennenttrue
.!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
la source
Votre code signifie:
Now
options.fields
est converti en valeur booléenne. Par définitionnull
,undefined
,0
,""
est converti enfalse
, ( la plupart du temps) toute autre chose est converti entrue
(mais je ne veux pas être si précis).Cela ne veut pas dire la même chose, car la
fields.length === 0
ligne. Les tableaux vides et autres objets sont convertis entrue
.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 Boolean
ne fonctionne pas et que l'utilisationtypeof(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.la source
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.
la source