Puis-je définir des variables non définies ou à passer définie comme argument?

StackOverflow https://stackoverflow.com/questions/2235622

  •  19-09-2019
  •  | 
  •  

Question

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

Qu'est-ce que if (!testvar) fait faire? Est-il pour tester undefined et null ou tout simplement undefined?

Une fois une variable est définie puis-je effacer revenir à undefined (suppression donc la variable)?

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

function test(var1, var2, var3) {

}

test("value1", undefined, "value2");
Était-ce utile?

La solution

  

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

Ne soyez pas confus au sujet null. Il est généralement sens et se comporte comme à d'autres concepts de la hors-bande « langages de script », « nul nul » ou « objets Aucun ».

undefined, d'autre part, est une bizarrerie bizarre JavaScript. Il est un objet singleton qui représente hors bande des valeurs, essentiellement un deuxième null similaire mais différent-. Il arrive:

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

  2. Lorsqu'une fonction n'a pas return value;, il retourne undefined. Il 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 pas encore attribué une valeur, il est undefined. Encore une fois, vous ne devriez pas vraiment besoin jamais compter sur cela.

  4. Le rendement de l'opérateur typeof fantasmagorique 'undefined' lorsque son opérande est une variable simple qui n'existe pas, au lieu de jeter un si vous avez essayé erreur normalement arriver à s'y référer. (Vous pouvez également donner une simple variable enveloppé entre parenthèses, mais pas une expression complète impliquant une variable non existant.) Pas grand-chose pour que l'utilisation soit.

  5. est controversée. Lorsque vous accédez à une propriété d'un objet qui n'existe pas, vous ne recevez pas immédiatement une erreur comme dans toutes les autres langues. Au lieu de cela, vous obtenez un objet undefined. (Et puis, quand vous essayez d'utiliser cet objet undefined plus tard dans le script, il va mal tourner d'une manière bizarre qui est beaucoup plus difficile à traquer que si JavaScript venait de jeter une erreur tout de suite.)

    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, 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 vaut mieux utiliser l'opérateur in, qui n'a pas été dans la version originale de Netscape JavaScript, mais il est disponible partout maintenant: 

    if ('prop' in o)
    ...

En résumé, undefined est un gâchis spécifique JavaScript, ce qui embrouille tout le monde. En dehors des arguments de la fonction optionnelle, où JS n'a pas d'autre mécanisme plus élégant, undefined doit être évité. Il ne devrait jamais avoir fait partie de la langue; null aurait travaillé très bien pour (2) et (3) et (4) est un disfonctionnement qui existe seulement parce qu'au début JavaScript avait aucune exception.

  

qu'est-ce que if (!testvar) fait faire? Est-il pour tester undefined et null ou tout simplement indéfini?

Un tel test vérifie « » de TRUTHINESS contre false, undefined, null, 0, NaN et chaînes vides. Mais dans ce cas, oui, il est vraiment undefined il est préoccupé par. OMI, il devrait être plus explicite à ce sujet et dire if (testvar!==undefined).

  

une fois une variable est définie puis-je effacer sur undefined (suppression donc la variable).

Vous pouvez certainement attribuer undefined à, mais qui ne supprime pas la variable. Seul l'opérateur de delete object.property supprime vraiment les choses.

delete est vraiment destiné à properts plutôt que des variables en tant que telles. Les navigateurs vous permettra de sortir avec delete variable droit, mais ce n'est pas une bonne idée et ne fonctionnera pas en mode strict de ECMAScript Cinquième édition. Si vous voulez libérer une référence à quelque chose de sorte qu'il peut être ordures collectées, il serait plus d'habitude de dire variable= null.

  

puis-je passer définie comme paramètre?

Oui.

Autres conseils

Vous ne pouvez pas (? Ne devrait pas) définir quoi que ce soit non défini, comme la variable ne serait plus undefined -. Vous venez de défini à quelque chose

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

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

Pour tester correctement pour undefined ou null, utilisez ceux-ci: 

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

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

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é mis intentionnellement la valeur ou si la valeur n'a pas encore été fixée, à moins que vous avez utilisé une erreur lourde attrapant: par exemple 

var a;

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

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

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

Consultez la référence ici au lieu de compter sur les gens disent dédaigneusement comme indésirable « En résumé, non défini est un gâchis spécifique JavaScript, ce qui embrouille tout le monde ». Tout simplement parce que vous êtes confus, cela ne signifie pas qu'il est un gâchis.

https://developer.mozilla.org/en-US/docs / Web / JavaScript / Référence / Global_Objects / undefined

Ce comportement est pas spécifique à 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

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

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

et non défini 

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

Vous pouvez attribuer un avariable avec indéfini. 

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

OUI, vous pouvez, parce que non définie créer votre propre variable non définie: 

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

Pour répondre à votre première question, l'opérateur ne (!) forcera ce qu'il est donné en une valeur booléenne. Alors null, 0, false, NaN et "" (chaîne vide) apparaît tout faux.

JavaScript, comment définir une variable non définie sur commandline:

Définir une variable non définie dans le terminal de ligne de commande javascript js qui vient 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:

Mettre cela en 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

AVERTISSEMENT! Lors du réglage de votre variable pour vous non défini définissez votre variable à une autre variable. Si une personne sournoise fonctionne undefined = 'rm -rf /'; alors chaque fois que vous définissez votre variable non définie, vous recevrez cette valeur.

Vous demandez peut-être comment je peux sortir les étrangers de valeur non définie au début et à le faire tourner encore. Il est à cause de javascript levage: http://www.adequatelygood.com/JavaScript-Scoping -et-Hoisting.html

Essayez ceci: 

// found on UglifyJS
variable = void 0;

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

if (document.getElementById)

L'identifiant est converti en une valeur booléenne, alors undefined est interprété comme false. Il y a bien sûr d'autres valeurs (comme 0 et « ») qui sont aussi interprétés comme false, mais soit l'identifiant ne devraient pas avoir raisonnablement une telle valeur ou vous êtes heureux avec le traitement d'une telle valeur la même que celle définie.

Javascript un opérateur delete qui peut être utilisé pour supprimer un membre d'un objet. En fonction de la portée d'une variable (à savoir si elle est globale ou non), vous pouvez le supprimer pour le rendre non défini.

Il n'y a pas de mot-clé undefined que vous pouvez utiliser comme un littéral non défini. Vous pouvez omettre les paramètres dans un appel de fonction pour les rendre non définie, mais qui ne peut être utilisé en envoyant moins paramters à la fonction, vous ne pouvez pas omettre un paramètre au milieu.

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

Cela fonctionne en créant un nouvel objet et en essayant d'accéder à une propriété sur elle avec un nom généré au hasard, que nous partons du principe existe et l'habitude aura donc la valeur de non dé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()];
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top