Puis-je définir des variables à undefined ou passer undefined comme argument?

Je suis un peu confus au sujet des valeurs undefined et null de JavaScript.

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

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

puis-je passer undefined comme paramètre? Par exemple: 

function test(var1, var2, var3) {

}

test("value1", undefined, "value2");
270
demandé sur Xufox 2010-02-10 12:20:04

10 réponses

Je suis un peu confus au sujet de Javascript non défini & null.

ne pas confondre avec null . Elle a généralement un sens et se comporte de la même manière que les concepts des autres langues de script pour les objets hors bande "nul", " nul " ou "aucun".

undefined , d'un autre côté, est une bizarrerie JavaScript. C'est un objet unique qui représente des valeurs hors-bande, essentiellement une seconde semblable-mais différent null .

  1. lorsque vous appelez une fonction avec moins d'arguments que la liste d'arguments dans les listes de déclarations function , les arguments non-traités sont définis à 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 dire la différence entre dosomething(1) et dosomething(1, undefined) ; arg2 sera la même valeur dans les deux. Si vous avez besoin de le dire la différence que vous pouvez regarder arguments.length , mais faire des arguments optionnels comme cela 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 n'avez pas encore attribué de valeur à cette variable, elle est undefined . Encore une fois, vous ne devrait pas vraiment jamais besoin de s'appuyer sur cela.

  4. spooky typeof opérateur renvoie la 'undefined' lors de son opérande est une simple variable qui n'existe pas, au lieu de jeter une erreur que l'on devrait normalement se produire si vous avez essayé de s'y référer. (Vous pouvez également lui donner une variable simple enveloppée entre parenthèses, mais pas une expression complète impliquant une variable non existante.) Pas beaucoup d'utilisation pour que, soit.

  5. C'est le sujet 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. À la place, vous obtenez un objet undefined . (Et puis quand vous essayez d'utiliser cet objet undefined plus tard dans le script, il va se tromper d'une manière étrange qui est beaucoup plus difficile à retrouver que si JavaScript avait juste jeté une erreur tout de suite.)

    c'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, parce que 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 l'opérateur in , qui n'était pas dans la version originale de JavaScript de Netscape, mais qui est disponible partout maintenant: 

    if ('prop' in o)
    ...

en résumé, undefined est un désordre spécifique au JavaScript, qui trouble 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 du langage; null aurait très bien fonctionné pour (2) et (3), et (4) est une erreur qui n'existe que parce Qu'au début JavaScript n'avait pas d'exceptions.

que fait réellement if (!testvar) ? Est-il tester pour Non défini et nul ou tout simplement non défini?

un tel contrôle de "véracité" contre false , undefined , null , 0 , NaN et des cordes vides. Mais dans ce cas, oui, il est vraiment undefined il s'intéresse. OMI, il devrait être plus explicite à ce sujet et de dire if (testvar!==undefined) .

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

vous pouvez certainement lui assigner undefined , mais cela ne supprimera pas la variable. Seul l'opérateur delete object.property enlève vraiment les choses.

delete est réellement destiné aux propriétés plutôt qu'aux variables en tant que telles. Les navigateurs vous permettront de vous en tirer avec delete variable , mais ce n'est pas une bonne idée et ne fonctionnera pas en mode strict de la cinquième édition D'ECMAScript. Si vous voulez libérer une référence à quelque chose afin qu'il puisse être ramassée par les ordures, il serait plus habituel de dire variable= null .

puis-je passer indéfini comme paramètre?

Oui.

471
répondu bobince 2017-02-26 16:13:11

on ne peut pas (ne doit pas?) définir quoi que ce soit comme non défini, car la variable ne serait plus non défini – vous venez défini à quelque chose.

on ne peut pas (ne doit pas?) passer undefined à une fonction. Si vous voulez passer une valeur vide, utilisez null à la place.

l'instruction if(!testvar) vérifie les valeurs vraies/fausses booléennes, celle-ci teste si testvar évalue à false . Par définition, null et undefined ne devraient pas être évalués ni comme true ou 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 les: 

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

if(testvar === null) { ... }
16
répondu Tatu Ulmanen 2010-05-12 18:51:26

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

si seulement null était disponible, vous ne seriez pas en mesure de déterminer si null a été défini intentionnellement comme la valeur ou si la valeur n'a pas encore été définie à moins que vous avez utilisé la capture d'erreur lourde: par exemple 

var a;

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

cependant, si vous mettez intentionnellement la valeur à null , l'égalité stricte avec undefined échoue, vous permettant ainsi de différencier entre null et undefined valeurs: 

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

vérifier la référence ici au lieu de compter sur les gens disant avec dédain junk comme "en résumé, indéfini est un désordre JavaScript spécifique, 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 au JavaScript et il complète le concept généralisé qu'un résultat booléen peut être true , false , inconnu ( null ), aucune valeur ( undefined ), ou quelque chose a mal tourné ( error ).

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

11
répondu Todd 2014-10-05 03:37:03

la meilleure façon de vérifier les valeurs nulles est 

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

et pour non défini 

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

vous pouvez assigner un avariable Non défini. 

testVar = undefined;
//typeof(testVar) will be equal to undefined.
8
répondu rahul 2010-02-10 09:33:50

pour répondre à votre première question, l'opérateur not ( ! ) forcera tout ce qui est donné dans une valeur booléenne. Donc null , 0 , false , NaN et "" (chaîne vide) apparaîtra false.

5
répondu Skilldrick 2010-02-10 09:32:24

OUI, vous le pouvez, parce que l'indéfini est défini comme indéfini. 

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

votre 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
4
répondu 2014-04-19 14:17:46

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

définit une variable non définie 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 à non définie dans un javascript:

mettez ça 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! Lors de la configuration de votre variable indéfinie vous configurez une variable à une autre variable. Si une personne sournoise exécute undefined = 'rm -rf /'; , alors chaque fois que vous définissez votre variable à undefined, vous recevrez cette valeur.

vous vous demandez peut-être comment je peux afficher la valeur non définie des aliens au début et la faire tourner. C'est à cause du hissage javascript: http://www.adequatelygood.com/JavaScript-Scoping-and-Hoisting.html

2
répondu Eric Leschinski 2014-01-08 20:18:23

essayez ceci: 

// found on UglifyJS
variable = void 0;
1
répondu Cqq Cqq 2017-09-22 10:42:56

le pour if (something) et if (!something) est couramment utilisé pour vérifier si quelque chose est défini ou non. Par exemple: 

if (document.getElementById)

l'identifiant est converti en valeur booléenne, donc undefined est interprété comme false . Il y a bien sûr d'autres valeurs (comme 0 et ") qui sont aussi interprétées comme false , mais soit l'identifiant ne devrait pas raisonnablement avoir une telle valeur, soit vous êtes heureux de traiter une telle valeur comme non définie.

Javascript dispose d'un opérateur delete qui peut être utilisé pour supprimer un membre d'un objet. Selon 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.

il n'y a pas de mot-clé undefined que vous pouvez utiliser comme un littéral Non dé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 dans le milieu.

0
répondu Guffa 2010-02-10 09:41:46

juste pour le plaisir, voici une façon assez sûre d'attribuer "non assigné" à une variable. Pour cela avoir une collision exigerait quelqu'un d'avoir ajouté au prototype pour objet avec exactement le même nom que la chaîne générée au hasard. Je suis sûr que le générateur de chaîne aléatoire pourrait être amélioré, mais je viens de prendre une de cette question: générer chaîne aléatoire / caractères en JavaScript

cela fonctionne en créant un nouvel objet et en essayant d'accéder une propriété sur elle avec une générés aléatoirement nom, qui nous supposons l'habitude existent et ont donc la valeur undefined. 

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
répondu rdans 2017-05-23 12:18:23