Déclaration vs Initialisation d'une variable?

Edit: @ThisClark a dit quelque chose dans les commentaires, et je suis allé prouver qu'il était mal, et après avoir lu la spécification, j'ai appris quelque chose:

Voici une information, sauf dans les spécifications :

Un état var déclare les variables qui sont scopées dans VariableEnvironment du contexte d'exécution en cours d'exécution. Les variables Var sont créées lorsqu'elles contiennent un environnement Lexique instancié et qu'elles sont initialisées à undefined lorsqu'elles sont créées. […] Une variable définie par une VariableDeclaration avec un Initialisateur est affectée de la valeur de l'Expédance d'Affectation de l'Initiateur lorsque la VariableDeclaration est exécutée, et non pas lorsque la variable est créée.

Sur la base de ma lecture, les points suivants décrivent le comportement (et l'utilisation correcte des termes) que vous avez posée dans votre question:

• Une déclaration de variable (par exemple, var foo ) provoque la création de cette variable dès que l'environnement «lexical» est instancié. Par exemple, si cette variable était définie dans un corps de fonction, cette fonction est l'environnement «lexical», et la création variable coïncide avec l'instanciation de la fonction elle-même.

• De toute évidence, les déclarations variables peuvent ou non être créées avec un initialiseur (c'est-à-dire l'expression de droite qui résout la valeur initiale de la variable). C'est une jolie utilisation de la non-spécification du terme "valeur initiale", mais … imaginons un peu plus:

• Techniquement , selon les notes de spécifications, toutes les variables sont initialisées avec la valeur undefined :

  Les variables sont créées […] et sont initialisées à indéfinis

  L'accent est mis sur «techniquement», car il est largement académique si un initialiseur était également fourni.

• Sur la base de ce que nous avons déjà abordé, il faut comprendre que la déclaration var foo; Pourrait exister n'importe où dans un corps de fonction, et le déplacer ailleurs dans la même fonction n'aurait aucun effet sur la sémantique d'exécution de la fonction elle-même (indépendamment du fait que des affectations réelles ou d'autres références aient lieu). Si cela est toujours confus, relisez les points précédents.

• Le dernier bit de comportement est la partie la plus intuitive, et c'est l' affectation de l' initialiseur . Cette affectation a lieu lorsque cette ligne de code est réellement exécutée (ce qui, à nouveau, n'est pas le même moment où la variable a été créée ).

Alors, pour récapituler rapidement:

• Toutes les déclarations de variables (qui utilisent var ) sont toujours initialisées avec undefined lors de l'initialisation de leur environnement lexical.
• Cette initialisation ne compte probablement pas comme une affectation , au sens technique (ha, @ThisClark, vous avez eu tort !!). 🙂
• Les affectations sont la partie simple, car elles se comportent de la même façon (et à l'heure) que vous attendez.

J'espère que cela aide (et que je n'ai pas mal interprété la spécification!).

Déclarer est l'introduction d'un nouveau nom dans le programme.

 var test; // Is this a declaration ? 

L'initialisation fait référence à la "cession" d'une valeur.

 var test = {first:"number_one"} // Now that object is initialized with value 

La déclaration signifie essentiellement l'introduction d'une nouvelle entité au programme. L'initialisation donne à une variable sa première valeur. Donc, fondamentalement, votre exemple ci-dessus est correct.

Tiré directement du MDN: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined :

La propriété globale non définie représente la valeur primitive indéfinie. C'est l'un des types primitifs de JavaScript.

En déclarant simplement une variable en Javascript, tel que l' var example initialise à la valeur primitive de indéfinie. Cela signifie que les deux expressions suivantes sont équivalentes:

 //equivalent expressions var ex1; var ex2 = undefined; //true! alert(ex2 === ex1); 

La seule différence est que l'instruction var initialise toutes les variables déclarées sans valeur undefined .

Dans les deux exemples, vous déclarez une variable.

Si vous attribuez une valeur à une variable sans l'instruction var , elle descendra dans la chaîne de l'étendue à la recherche de variables déclarées, éventuellement en revenant à l'objet de window global.

Il y a une petite chose qui vous manque ici. Une analogie pour comprendre le concept est comme ceci. Pour chaque variable, il doit y avoir une certaine valeur.

La valeur par défaut pour toutes les variables (si non explicitement mentionnée est indéfinie)

 1) var example; // this is declaring and initializing with undefined 2) example="hi"; // this is assigning the value to hi 3) var example = "hi" // this is declaring and initializing with "hi" 

Donc la 3ème déclaration est effectivement la même que 1 + 2.

Maintenant, une question peut survenir lorsque la déclaration 3ème est possible, pourquoi avons-nous besoin de la déclaration 1?

La raison en est d'étendre la portée de la variable.

Par exemple, disons qu'une variable est requise à la ligne numéro 8. Mais la valeur n'est pas disponible jusqu'à la fin et dans le bloc de code.

 1) { 2) var a; 3) try{ 4) a=someFunctionWhichMayThroeException(); 5) } 6) catch(e){ 7) a=100; 8) } 9) someFunctionOnA(a);// the variable is required here 10) 11) } 

En déclarant la variable ci-dessus, nous avons augmenté la portée de la variable, donc elle peut être utilisée en dehors du bloc try.

PS: ce n'est qu'un exemple trivial de l'utilisation.