Puis-je définir des variables comme étant indéfinies ou passer des variables indéfinies comme argument ?

Question

Je suis un peu confus au sujet de la méthode JavaScript. undefined y null valeurs.

Qu'est-ce que if (!testvar) font réellement ? Est-ce qu'il teste undefined y null ou simplement undefined ?

Une fois qu'une variable est définie, puis-je la remettre à l'état initial ? undefined (en supprimant donc la variable) ?

Puis-je passer undefined en tant que paramètre ? Par exemple :

function test(var1, var2, var3) {

}

test("value1", undefined, "value2");

Answer 1

Je suis un peu confus au sujet de Javascript undefined & null.

null se comporte généralement de la même manière que les concepts des autres langages de script concernant les objets hors bande "null", "nil" ou "None".

undefined d'un autre côté, est une bizarrerie de JavaScript. Il s'agit d'un objet singleton qui représente les valeurs hors bande, essentiellement un deuxième objet similaire mais différent. null . Il apparaît :

1. Lorsque vous appelez une fonction avec un nombre d'arguments inférieur à la liste d'arguments de l'option function les arguments non passés sont définis comme suit undefined . Vous pouvez tester cela avec par exemple.. :

   function dosomething(arg1, arg2) {
       if (arg2===undefined)
       arg2= DEFAULT_VALUE_FOR_ARG2;
       ...
   }

   Avec cette méthode, vous ne pouvez pas faire la différence entre dosomething(1) y dosomething(1, undefined) ; arg2 sera la même valeur dans les deux. Si vous avez besoin de faire la différence, vous pouvez consulter les documents suivants arguments.length mais faire des arguments optionnels comme ça n'est généralement pas très lisible.

2. Lorsqu'une fonction n'a pas de return value; il renvoie undefined . Il n'est généralement pas nécessaire d'utiliser un tel résultat de retour.

3. Lorsque vous déclarez une variable en ayant un var a dans un bloc, mais que vous ne lui avez pas encore attribué de valeur, il est undefined . Encore une fois, vous ne devriez jamais avoir besoin de compter sur cela.

4. L'effrayant typeof L'opérateur retourne 'undefined' lorsque son opérande est une simple variable qui n'existe pas, au lieu de lancer une erreur comme cela se produirait normalement si vous essayiez d'y faire référence. (Vous pouvez également lui donner une simple variable entourée de parenthèses, mais pas une expression complète impliquant une variable inexistante). Cela ne sert pas à grand-chose non plus.

5. C'est celui qui est controversé. Lorsque vous accédez à une propriété d'un objet qui n'existe pas, vous n'obtenez pas immédiatement une erreur comme dans tous les autres langages. Au lieu de cela, vous obtenez un undefined objet. (Et ensuite quand vous essayez d'utiliser cet undefined plus tard dans le script, il se trompera d'une manière bizarre qui sera beaucoup plus difficile à retracer que si JavaScript avait juste lancé une erreur directement).

   Ceci est souvent utilisé pour vérifier l'existence de propriétés :

   if (o.prop!==undefined) // or often as truthiness test, if (o.prop)
      ...do something...

   Cependant, comme vous pouvez attribuer undefined comme toute autre valeur :

   o.prop= undefined;

   qui ne détecte pas réellement si la propriété est là de manière fiable. Il est préférable d'utiliser le in qui n'était pas dans la version originale de JavaScript de Netscape, mais qui est maintenant disponible partout :

   if ('prop' in o)
       ...

En résumé, undefined est un désordre propre à JavaScript, qui embrouille tout le monde. En dehors des arguments de fonction optionnels, où JS n'a pas d'autre mécanisme plus élégant, undefined devrait être évitée. Il n'aurait jamais dû faire partie de la langue ; null aurait très bien fonctionné pour (2) et (3), et (4) est un défaut qui n'existe que parce qu'au début JavaScript n'avait pas d'exceptions.

que fait if (!testvar) font réellement ? Teste-t-il pour undefined et null ou juste undefined ?

Un tel test de "véracité" permet de vérifier false , undefined , null , 0 , NaN et des chaînes vides. Mais dans ce cas, oui, c'est vraiment undefined dont il s'agit. IMO, il devrait être plus explicite à ce sujet et dire if (testvar!==undefined) .

une fois qu'une variable est définie, puis-je la remettre à l'état indéfini (ce qui supprime la variable) ?

Vous pouvez certainement attribuer undefined mais cela ne supprimera pas la variable. Seul le delete object.property L'opérateur supprime vraiment les choses.

delete est vraiment destiné aux propriétés plutôt qu'aux variables en tant que telles. Les navigateurs vous permettront de vous en sortir avec de simples delete variable mais ce n'est pas une bonne idée et cela ne fonctionnera pas dans le mode strict d'ECMAScript Fifth Edition. Si vous voulez libérer une référence à quelque chose pour qu'elle puisse être collectée, il serait plus habituel de dire variable= null .

puis-je passer undefined comme paramètre ?

Oui.

Answer 2

Vous ne pouvez pas (ne devriez pas ?) définir quelque chose comme étant indéfini, car la variable ne serait plus indéfinie. défini à quelque chose.

Vous ne pouvez pas (ne devez pas ?) passer undefined à une fonction. Si vous voulez passer une valeur vide, utilisez null à la place.

La déclaration if(!testvar) vérifie les valeurs booléennes vrai/faux, ce test particulier vérifie si testvar évalue à false . Par définition, null y undefined ne doit pas être évalué non plus comme true ou false mais JavaScript évalue null comme false et émet une erreur si vous essayez d'évaluer une variable non définie.

Pour tester correctement les undefined ou null utilisez-les :

if(typeof(testvar) === "undefined") { ... }

if(testvar === null) { ... }

Answer 3

La meilleure façon de vérifier si une valeur est nulle est

if ( testVar !== null )
{
    // do action here
}

et pour les indéfinis

if ( testVar !== undefined )
{
    // do action here
}

Vous pouvez assigner une variable avec undefined.

testVar = undefined;
//typeof(testVar) will be equal to undefined.

Answer 4

OUI, vous pouvez, parce qu'indéfini est défini comme indéfini.

console.log(
   /*global.*/undefined === window['undefined'] &&
   /*global.*/undefined === (function(){})() &&
   window['undefined']  === (function(){})()
) //true

votre affaire :

test("value1", undefined, "value2")

vous pouvez également créer votre propre variable indéfinie :

Object.defineProperty(this, 'u', {value : undefined});
console.log(u); //undefined

Answer 5

Pour répondre à votre première question, l'opérateur not ( ! ) transformera tout ce qui lui est donné en une valeur booléenne. Donc null , 0 , false , NaN y "" (chaîne vide) apparaîtront tous faux.