Vérification null JavaScript

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 que typeof.

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 ainsi dataune variable non définie et levant une erreur sur data != null.

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

• La fonction a été appelée avec un argument non nul, auquel cas elle passera trivialement à la fois data != null et data !== 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é.

Une «variable non dé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 aucune erreur. Vous avez raison d'être != nullsuivi en !== undefinedétant inutile, cependant.

En JavaScript, nullest 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:

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

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:

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

De plus, 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, é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".

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

Cet extrait revient à dire "si la fonction a été appelée avec un argument défini et non nul ..."

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)

function test(data) {
    if (data != null) {
        console.log('Data: ', data);
    }
}

test();          // the data=undefined
test(null);      // the data=null
test(undefined); // the data=undefined

test(0); 
test(false); 
test('something');

Ici vous avez tout ( src ):

si

== (sa négation ! = )

=== (sa négation ! == )

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, datasera 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:

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

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.

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:

function (data) {
  if (data != null && data !== undefined) {
    // some code here
    // but what if data === false?
    // or data === '' - empty string?
  }
}

faites quelque chose comme ça:

function (data) {
  if (typeof data === 'string' && data.length) {
    // consume string here, it is here for sure
    // cleaner, it is obvious what type you expect
    // safer, less error prone due to implicit coercion
  } 
}

typeof foo === "undefined"est différent de foo === 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

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

Éditer:

Vous ne pouvez pas utiliser foo === undefinedpour 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");
}

La façon simple de faire votre test est:

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

var a;
alert(a); //Value is undefined

var b = "Volvo"; 
alert(b); //Value is Volvo

var c = null;
alert(c); //Value is null