J'ai rencontré le code suivant:
function test(data) {
if (data != null && data !== undefined) {
// some code here
}
}
Je suis un peu nouveau dans JavaScript, mais, d'après d'autres questions que j'ai lues ici, j'ai l'impression que ce code n'a pas beaucoup de sens.
Vous obtiendrez une erreur si vous accédez à une variable non définie dans un contexte autre quetypeof
.
Mise à jour: La (citation de la) réponse ci-dessus peut être trompeuse. Il devrait dire «une variable non déclarée» , au lieu de «une variable non définie» .
Comme je l'ai découvert, dans les réponses de Ryan ♦ , maerics et nwellnhof , même si aucun argument n'est fourni à une fonction, ses variables pour les arguments sont toujours déclarées. Ce fait prouve également faux le premier élément de la liste ci-dessous.
D'après ce que je comprends, les scénarios suivants peuvent être rencontrés:
La fonction a été appelée sans argument, créant ainsidata
une variable non définie et levant une erreur surdata != null
.La fonction a été appelée spécifiquement avec
null
(ouundefined
), comme argument, auquel casdata != null
protège déjà le code interne, le rendant&& data !== undefined
inutile.La fonction a été appelée avec un argument non nul, auquel cas elle passera trivialement à la fois
data != null
etdata !== undefined
.
Q: Ma compréhension est-elle correcte?
J'ai essayé ce qui suit, dans la console de Firefox:
--
[15:31:31.057] false != null
[15:31:31.061] true
--
[15:31:37.985] false !== undefined
[15:31:37.989] true
--
[15:32:59.934] null != null
[15:32:59.937] false
--
[15:33:05.221] undefined != null
[15:33:05.225] false
--
[15:35:12.231] "" != null
[15:35:12.235] true
--
[15:35:19.214] "" !== undefined
[15:35:19.218] true
Je ne peux pas comprendre un cas où l' data !== undefined
après data != null
pourrait être d'une quelconque utilité.
la source
if (data)
. C'est un moyen Javascript mnémotechnique pour vérifier si ladata
variable vaut true.undefined
,null
, Faux, 0, chaîne vide, tableau vide et objet (?) Sans propriété est évaluée à false, le reste est vrai.if(data)
signifierait qu'il ne peut pas passerfalse
ou0
comme valeurs pourdata
.if(typeof someUndefVar == whatever) -- works
etif(someUnderVar) -- error
.data !== null && data !== undefined
, ce qui équivaut àdata != null
ce qui équivaut àdata != undefined
. La première forme a tendance à être favorisée car elle est plus explicite sur les conditions, alors qu'il serait facile d'oublier les deuxnull
etundefined
qu'elles sont vérifiées avec les deux dernières conditions.undefined
IMO sont une odeur de code. Ce n'est pas un mot-clé protégé commenull
, c'est une variable qui se trouve être indéfinie. Ceci est tout à fait valide et va casser votre code:undefined = 1
Réponses:
Une «variable non définie» est différente de la valeur
undefined
.Une variable non définie:
Une variable avec la valeur
undefined
:Lorsqu'une fonction prend un argument, cet argument est toujours déclaré même si sa valeur est
undefined
, et il n'y aura donc aucune erreur. Vous avez raison d'être!= null
suivi en!== undefined
étant inutile, cependant.la source
data !== null && data !== undefined
aurait du sens, cependant.data != null
vérifierait les deuxnull
etundefined
(mais, fait intéressant, juste pournull
etundefined
, et pas les autres valeurs fausses).En JavaScript,
null
est un objet singleton spécial qui est utile pour signaler "aucune valeur". Vous pouvez le tester par comparaison et, comme d'habitude en JavaScript, c'est une bonne pratique d'utiliser l'===
opérateur pour éviter de confondre la coercition de type:Comme le mentionne @rynah, "indéfini" est un peu déroutant en JavaScript. Cependant, il est toujours prudent de tester si la
typeof(x)
chaîne est "indéfinie", même si "x" n'est pas une variable déclarée:De plus, les variables peuvent avoir la "valeur indéfinie" si elles ne sont pas initialisées:
En mettant tout cela ensemble, votre chèque devrait ressembler à ceci:
Cependant, étant donné que la variable "data" est toujours définie car il s'agit d'un paramètre de fonction formel, l'utilisation de l'opérateur "typeof" n'est pas nécessaire et vous pouvez en toute sécurité comparer directement avec la "valeur non définie".
Cet extrait revient à dire "si la fonction a été appelée avec un argument défini et non nul ..."
la source
!= null
sera vrai pour toutes les valeurs saufnull
etundefined
, et nous sommes sûrs que cette variable est déclarée.typeof
dans d'autres situations, cela peut même être dangereux - et si vous saisissez mal le nom de la variable? Cela peut passer inaperçu pendant longtemps car il n'y a pas d'erreur.!=
du tout, seule comparaison stricte,!==
?===
) à moins que vous ne sachiez vraiment ce que vous faites et que vous souhaitiez une comparaison après la conversion (==
).undefined
. De plus, Safari sur iPad ne le fera en aucun cas. Vous ne pouvez même pasdelete window.undefined
.Dans votre cas, utilisez
data==null
(qui est vrai UNIQUEMENT pour null et indéfini - sur la deuxième image, focus sur les lignes / colonnes null-undefined)Afficher l'extrait de code
Ici vous avez tout ( src ):
si
== (sa négation ! = )
=== (sa négation ! == )
la source
Q: La fonction a été appelée sans argument, faisant ainsi des données une variable non définie et générant une erreur sur les données! = Null.
R: Oui,
data
sera défini sur indéfini. Voir section 10.5 Déclaration de liaison Instanciation de la spécification. Mais accéder à une valeur non définie ne génère pas d'erreur. Vous confondez probablement cela avec l'accès à une variable non déclarée en mode strict, ce qui génère une erreur.Q: La fonction a été appelée spécifiquement avec null (ou non défini) comme argument, auquel cas data! = Null protège déjà le code interne, rendant && data! == undefined inutile.
Q: La fonction a été appelée avec un argument non nul, auquel cas elle passera trivialement les données! = Null et les données! == non définies.
R: Correct. Notez que les tests suivants sont équivalents:
Voir la section 11.9.3 L'algorithme de comparaison d'égalité abstraite et la section 11.9.6 L'algorithme de comparaison d'égalité stricte de la spécification.
la source
data
cela n'existerait pas du tout, au lieu d'être régléundefined
. J'apprécie la clarification, et ces références m'ont aidé à mieux comprendre comment fonctionnent les deux égalités.Je pense que tester des variables pour des valeurs auxquelles vous ne vous attendez pas n'est pas une bonne idée en général. Parce que le test est le vôtre, vous pouvez le considérer comme l'écriture d'une liste noire de valeurs interdites. Mais que faire si vous oubliez de lister toutes les valeurs interdites? Quelqu'un, même vous, peut déchiffrer votre code en passant une valeur inattendue. Donc, une approche plus appropriée est quelque chose comme la liste blanche - tester les variables uniquement pour les valeurs attendues, pas inattendues. Par exemple, si vous vous attendez à ce que la valeur des données soit une chaîne, au lieu de ceci:
faites quelque chose comme ça:
la source
typeof foo === "undefined"
est différent defoo === undefined
, ne les confondez jamais.typeof foo === "undefined"
est ce dont vous avez vraiment besoin. Utilisez également!==
à la place de!=
Ainsi, la déclaration peut être écrite comme
Éditer:
Vous ne pouvez pas utiliser
foo === undefined
pour les variables non déclarées.la source
foo === undefined
dangereux à utiliser. Cela fait échouer votre code pour la même condition que vous essayiez d'éviter.foo === undefined
est parfaitement acceptable dans la situation du PO (en supposant qu'ilundefined
n'a pas été annulé). La réponse ne parvient pas non plus à expliquer pourquoi!==
devrait être utilisé à la place de!=
.La façon simple de faire votre test est:
la source
data
est une chaîne, ce test renvoie false sur les chaînes vides, ce qui peut, ou non, être approprié (la fonction peut vouloir traiter la chaîne vide d'une manière ou d'une autre).""
ou0
ouNaN
(ou autres) le bloc "if" sera ignoré; ce qui peut ou non être l'intention d'OP.la source
null
.