web-dev-qa-db-fra.com

Puis-je définir des variables sur non défini ou passer non défini en argument?

Les valeurs undefined et null de JavaScript me semblent un peu confuses.

Que fait réellement if (!testvar)? Est-ce qu'il teste undefined et null ou simplement undefined?

Une fois qu'une variable est définie, puis-je la remettre à undefined (donc supprimer la variable)?

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

function test(var1, var2, var3) {

}

test("value1", undefined, "value2");
javascriptundefined
291
AJ.

Je suis un peu confus à propos de Javascript non défini & null.

Ne soyez pas confus à propos de null. Il est généralement logique et se comporte de la même manière que les concepts d’autres langages de script pour les objets "null", "nil" ou "Aucun" hors bande.

undefined, d'autre part, est une bizarrerie JavaScript étrange. C'est un objet singleton qui représente des valeurs hors bande, essentiellement un second null, similaire mais différent. Il se présente:

  1. Lorsque vous appelez une fonction avec moins d'arguments que la liste d'arguments dans les listes d'instructions function, les arguments non passés sont définis sur undefined. Vous pouvez tester pour 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) et dosomething(1, undefined); arg2 aura la même valeur dans les deux cas. Si vous avez besoin de faire la différence, vous pouvez regarder arguments.length, mais faire des arguments optionnels comme celui-là n'est généralement pas très lisible.

  2. Lorsqu'une fonction n'a pas de return value;, elle retourne 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 une instruction var a dans un bloc, mais que vous ne lui avez pas encore attribué de valeur, il s’agit de undefined. Encore une fois, vous ne devriez jamais vraiment avoir besoin de vous fier à cela.

  4. L'opérateur spooky typeof retourne 'undefined' lorsque son opérande est une simple variable inexistante, au lieu de générer une erreur comme cela se produirait normalement si vous tentiez de vous y référer. (Vous pouvez également lui donner une simple variable entourée de parenthèses, mais pas une expression complète impliquant une variable inexistante.) Pas beaucoup d'utilisation pour cela non plus.

  5. C'est le 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 toutes les autres langues. Au lieu de cela, vous obtenez un objet undefined. (Et ensuite, lorsque vous essayez d'utiliser cet objet undefined plus tard dans le script, il se produira une erreur étrange beaucoup plus difficile à détecter que si JavaScript venait de générer une erreur.)

    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, étant donné que vous pouvez affecter undefined comme toute autre valeur:

    o.prop= undefined;

    cela ne détecte pas réellement si la propriété est là de manière fiable. Mieux vaut utiliser l'opérateur in, qui ne figurait pas dans la version originale de JavaScript de Netscape, mais qui est disponible partout à l'heure actuelle:

    if ('prop' in o)
    ...

En résumé, undefined est un désordre spécifique à JavaScript, qui confond tout le monde. En dehors des arguments de fonction optionnels, pour lesquels JS ne dispose d'aucun autre mécanisme plus élégant, il convient d'éviter undefined. Cela n'aurait jamais dû faire partie de la langue. null aurait bien fonctionné pour (2) et (3), et (4) est un défaut qui n'existe que parce qu'au début, JavaScript n'avait aucune exception.

que fait réellement if (!testvar)? Est-ce qu'il teste undefined et null ou juste undefined?

Un tel test de "véracité" vérifie contre false, undefined, null, 0, NaN et les chaînes vides. Mais dans ce cas, oui, il s’agit bien de undefined. OMI, il devrait être plus explicite à ce sujet et dire if (testvar!==undefined).

une fois qu'une variable est définie, puis-je la ramener à undefined (donc supprimer la variable).

Vous pouvez certainement lui affecter undefined, mais cela ne supprimera pas la variable. Seul l'opérateur delete object.property supprime réellement les choses.

delete est vraiment destiné aux propriétés plutôt qu'aux variables en tant que telles. Les navigateurs vous laisseront vous débrouiller avec delete variable direct, 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 le ramasser, il serait plus habituel de dire variable= null.

puis-je passer indéfini en tant que paramètre?

Oui.

498
bobince

Vous ne pouvez pas (ne devriez pas?) Définir quoi que ce soit comme indéfini, car la variable ne serait plus indéfinie - vous venez défini quelque chose.

Vous ne pouvez pas (ne devriez pas?) Passer undefined à une fonction. Si vous souhaitez passer une valeur vide, utilisez plutôt null.

L'instruction if(!testvar) vérifie les valeurs booléennes true/false. Celle-ci vérifie si testvar est évalué à false. Par définition, null et undefined ne devraient pas être évalués ni comme true ni false, mais JavaScript évalue null comme false et donne une erreur si vous essayez d'évaluer une variable non définie.

Pour tester correctement undefined ou null, utilisez ce qui suit:

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

if(testvar === null) { ... }
16
Tatu Ulmanen

La différence fondamentale est que undefined et null représentent des concepts différents.

Si seulement null était disponible, vous ne pourriez pas déterminer si null a été défini volontairement comme valeur ou si la valeur n'a pas encore été définie, à moins que vous n'ayez utilisé une capture d'erreur encombrante: par exemple

var a;

a == null; // This is true
a == undefined; // This is true;
a === undefined; // This is true;

Toutefois, si vous définissez intentionnellement la valeur sur null, une égalité stricte avec undefined échoue, vous permettant ainsi de différencier les valeurs null et undefined:

var b = null;
b == null; // This is true
b == undefined; // This is true;
b === undefined; // This is false;

Vérifiez la référence ici au lieu de vous fier à ce que des gens disent de façon nonchalante et indésirable des ordures telles que "En résumé, indéfini est un désordre spécifique à JavaScript, qui confond tout le monde". Juste parce que vous êtes confus, cela ne signifie pas que c'est un gâchis.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined

Ce comportement n'est pas non plus spécifique à JavaScript et complète le concept généralisé selon lequel un résultat booléen peut être true, false, unknown (null), aucune valeur (undefined) , ou quelque chose s'est mal passé (error).

http://en.wikipedia.org/wiki/Undefined_value

12
Todd

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

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

et pour indéfini

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

Vous pouvez assigner une variable avec undefined.

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

OUI, vous pouvez, car indéfini est défini comme indéfini.

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

ton cas:

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

vous pouvez aussi créer votre propre variable non définie:

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

Pour répondre à votre première question, l'opérateur not (!) va forcer quoi que ce soit qui lui est donné dans une valeur booléenne. Ainsi, null, 0, false, NaN et "" (chaîne vide) apparaîtront tous comme faux.

5
Skilldrick

JavaScript, comment définir une variable sur non définie en ligne de commande:

Définissez une variable sur non défini dans le terminal de ligne de commande javascript js fourni avec Java sur Ubuntu 12.10.

el@defiant ~ $ js

js> typeof boo
"undefined"

js> boo
typein:2: ReferenceError: boo is not defined

js> boo=5
5

js> typeof boo
"number"

js> delete(boo)
true

js> typeof boo
"undefined"

js> boo
typein:7: ReferenceError: boo is not defined

Si vous définissez une variable sur indéfinie en javascript:

Mettez ceci dans myjs.html:

<html>
<body>
    <script type="text/JavaScript">
        document.write("aliens: " + aliens);
        document.write("typeof aliens: " + (typeof aliens));
        var aliens = "scramble the nimitz";
        document.write("found some aliens: " + (typeof aliens));
        document.write("not sayings its aliens but... " + aliens);
        aliens = undefined;
        document.write("aliens deleted");
        document.write("typeof aliens: " + (typeof aliens));
        document.write("you sure they are gone? " + aliens);
    </script>
</body>
</html>

Il imprime ceci:

aliens: undefined
typeof aliens: undefined
found some aliens: string
not sayings its aliens but... scramble the nimitz
aliens deleted
typeof aliens: undefined
you sure they are gone? undefined

ATTENTION! Lorsque vous définissez votre variable sur non définie, vous définissez votre variable sur une autre variable. Si une personne sournoise exécute undefined = 'rm -rf /'; alors chaque fois que vous définissez votre variable sur non définie, vous recevrez cette valeur.

Vous vous demandez peut-être comment je peux sortir les extraterrestres de valeur indéfinie au début et le faire continuer. C'est à cause de javascript hissage: http://www.équentementgood.com/JavaScript-Scoping-and-Hoisting.html

2
Eric Leschinski

Essaye ça:

// found on UglifyJS
variable = void 0;
2
Cqq Cqq

Juste pour le plaisir, voici un moyen relativement sûr d’affecter "non affecté" à une variable. Pour que cela ait une collision, il faudrait que quelqu'un ait ajouté au prototype pour Object avec exactement le même nom que la chaîne générée aléatoirement. Je suis sûr que le générateur de chaînes aléatoires pourrait être amélioré, mais je viens d'en prendre une de cette question: Générer des chaînes/caractères aléatoires en JavaScript

Cela fonctionne en créant un nouvel objet et en essayant d’accéder à une propriété dessus avec un nom généré aléatoirement, ce qui, nous le supposons, n’existera pas et aura donc la valeur indéfinie.

function GenerateRandomString() {
    var text = "";
    var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

    for (var i = 0; i < 50; i++)
        text += possible.charAt(Math.floor(Math.random() * possible.length));

    return text;
}

var myVar = {}[GenerateRandomString()];
0
rdans

Les fonctions for if (something) et if (!something) sont généralement utilisées pour vérifier si quelque chose est défini ou non. Par exemple:

if (document.getElementById)

L'identifiant est converti en une valeur booléenne, ainsi undefined est interprété comme false. Il existe bien sûr d'autres valeurs (telles que 0 et '') qui sont également interprétées comme false, mais l'identificateur ne doit pas raisonnablement avoir une telle valeur ou vous souhaitez que cette valeur soit traitée de la même manière que non définie.

Javascript possède un opérateur delete qui peut être utilisé pour supprimer un membre d'un objet. En fonction de la portée d’une variable (c’est-à-dire si elle est globale ou non), vous pouvez la supprimer pour la rendre non définie.

Vous ne pouvez pas utiliser de mot clé undefined comme littéral indéfini. Vous pouvez omettre des paramètres dans un appel de fonction pour les rendre non définis, mais cela ne peut être utilisé qu'en envoyant moins de paramètres à la fonction, vous ne pouvez pas omettre un paramètre au milieu.

0
Guffa