Vérification des nullités en JavaScript

Question

Je suis tombé sur le code suivant :

function test(data) {
    if (data != null && data !== undefined) {
        // some code here
    }
}

Je suis quelque peu novice en JavaScript, mais d'après les autres questions que j'ai lues ici, j'ai l'impression que ce code n'a pas beaucoup de sens.

---

En particulier, cette réponse déclare que

Vous obtiendrez une erreur si vous accédez à une variable non définie dans un contexte autre que typeof .

Mise à jour : La (citation de la) réponse ci-dessus peut être trompeuse. Elle devrait dire "une variable non déclarée" au lieu de "une variable indéfinie" .

Comme je l'ai découvert, dans les réponses de Ryan , maérique y nwellnhof Ainsi, même lorsqu'une fonction n'a pas d'arguments, les variables correspondant à ces arguments sont toujours déclarées. Ce fait prouve également que le premier élément de la liste ci-dessous est faux.

---

D'après ce que je comprends, les scénarios suivants peuvent se produire :

• La fonction a été appelée sans arguments, ce qui fait que data une variable non définie, et en levant une erreur sur data != null .

• La fonction a été appelée spécifiquement avec null (ou undefined ), comme argument, auquel cas data != null protège déjà le code interne, rendant && data !== undefined inutile.

• La fonction a été appelée avec un argument non nul, dans ce cas elle passera trivialement les deux data != null y data !== undefined .

Q : Est-ce que je comprends bien ?

---

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 n'arrive pas à trouver un cas où les data !== undefined après data != null pourrait être d'une quelconque utilité.

Answer 1

Une "variable indéfinie" est différente de la valeur undefined .

Une variable non définie :

var a;
alert(b); // ReferenceError: b is not defined

Une variable avec la valeur undefined :

var a;
alert(a); // Alerts “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 pas d'erreur. Vous avez raison sur != null suivi par !== undefined être inutile, cependant.

Answer 2

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 la balise === pour éviter de confondre la coercition de type :

var a = null;
alert(a === null); // true

Comme @rynah le mentionne, "undefined" est un peu confus en JavaScript. Cependant, il est toujours prudent de tester si la fonction typeof(x) est la chaîne "undefined", même si "x" n'est pas une variable déclarée :

alert(typeof(x) === 'undefined'); // true

De même, les variables peuvent avoir la "valeur indéfinie" si elles ne sont pas initialisées :

var y;
alert(typeof(y) === 'undefined'); // true

En mettant tout cela ensemble, votre chèque devrait ressembler à ceci :

if ((typeof(data) !== 'undefined') && (data !== null)) {
  // ...

Cependant, comme la variable "data" est toujours définie puisqu'il s'agit d'un paramètre de fonction formel, l'utilisation de l'opérateur "typeof" est inutile et vous pouvez en toute sécurité comparer directement avec la "valeur indéfinie".

function(data) {
  if ((data !== undefined) && (data !== null)) {
    // ...

Ce bout de phrase revient à dire "si la fonction a été appelée avec un argument qui est défini et qui n'est pas nul...".

Answer 3

Q : La fonction a été appelée sans arguments, faisant ainsi de data une variable indéfinie, et générant une erreur si data != null.

A : Oui, data sera défini comme indéfini. Voir section 10.5 Instanciation de liaison de déclaration de la spécification. Mais l'accès à une valeur non définie n'entraîne pas d'erreur. Vous confondez probablement cela avec l'accès à une variable non déclarée en mode strict, qui entraîne une erreur.

Q : La fonction a été appelée spécifiquement avec null (ou undefined), 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, dans ce cas elle passera trivialement à la fois data != null et data !== undefined.

A : Correct. Notez que les tests suivants sont équivalents :

data != null
data != undefined
data !== null && data !== undefined

Voir section 11.9.3 L'algorithme de comparaison d'égalité abstraite y section 11.9.6 L'algorithme de comparaison d'égalité stricte de la spécification.

Answer 4

typeof foo === "undefined" est différent de foo === undefined ne les confondez jamais. typeof foo === "undefined" est ce dont vous avez vraiment besoin. De plus, utilisez !== à la place de !=

La déclaration peut donc être écrite comme suit

function (data) {
  if (typeof data !== "undefined" && data !== null) {
    // some code here
  }
}

Editar:

Vous ne pouvez pas utiliser foo === undefined pour les variables non déclarées.

var t1;

if(typeof t1 === "undefined")
{
  alert("cp1");
}

if(t1 === undefined)
{
  alert("cp2");
}

if(typeof t2 === "undefined")
{
  alert("cp3");
}

if(t2 === undefined) // fails as t2 is never declared
{
  alert("cp4");
}

Answer 5

La façon la plus simple de faire votre test est :

function (data) {
    if (data) { // check if null, undefined, empty ...
        // some code here
    }
}