From da78a9e329e272dedb2400b79a3bdeebff387d47 Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 8 Dec 2020 14:42:17 -0500 Subject: initial commit --- .../javascript/reference/statements/var/index.html | 221 +++++++++++++++++++++ 1 file changed, 221 insertions(+) create mode 100644 files/it/web/javascript/reference/statements/var/index.html (limited to 'files/it/web/javascript/reference/statements/var') diff --git a/files/it/web/javascript/reference/statements/var/index.html b/files/it/web/javascript/reference/statements/var/index.html new file mode 100644 index 0000000000..41ee508d3c --- /dev/null +++ b/files/it/web/javascript/reference/statements/var/index.html @@ -0,0 +1,221 @@ +--- +title: var +slug: Web/JavaScript/Reference/Statements/var +tags: + - Dichiarazioni + - Globali + - JavaScript + - Locali + - Valore + - Variabili + - funzione +translation_of: Web/JavaScript/Reference/Statements/var +--- +
{{jsSidebar("Statements")}}
+ +

La dichiarazione variabile  dichiara una variabile, opzionalmente inizializzabile ad un valore.

+ +
{{EmbedInteractiveExample("pages/js/statement-var.html")}}
+ + + +

Sintassi

+ +
var nomevariabile1 [= valore1] [, nomevariabile2 [= valore2] ... [, nomevariabileN [= valoreN]]];
+ +
+
nomevariabileN
+
Il nome della variabile. Può essere qualunque identificatore legale.
+
+ +
+
valoreN
+
Valore iniziale della variabile. Può essere qualunque espressione legale. Il valore di default è undefined (non definito).
+
+ +

 Descrizione

+ +

Le dichiarazioni di variabile, ovunque appaiano, sono processate prima dell'esecuzione di qualsiasi codice. L'ambiente di una variabile dichiarata con var è il suo attuale contesto di esecuzione, che è la funzione di chiusura o, per le variabili dichiarate al di fuori di qualsiasi funzione, globale. Se si dichiara nuovamente una variabile JavaScript, il suo valore non sarà perso.

+ +

Assegnando un valore a una variabile non dichirata la rende implicitamente globale (diventa una proprietà dell'oggetto) quando viene eseguita. Le differenze fra variabili dichiarate e non dichiarate sono:

+ +

1. Le variabili dichiarate sono legate al contesto in cui sono dichiarate. Quelle non dichiarate sono sempre globali.

+ +
function x() {
+  y = 1;   // Genera un ReferenceError in strict mode
+  var z = 2;
+}
+
+x();
+
+console.log(y); // scrive "1" in console
+console.log(z); // Genera un ReferenceError: z non è definita fuori dalla funzione x
+
+ +

2. Variabili dichiarate sono create prima dell'esecuzione del codice. Variabili non dichiarate non esistono finchè il codice assegnato loro non viene eseguito.

+ +
console.log(a);                // Genera un ReferenceError.
+console.log('still going...'); // Non verrà eseguito.
+ +
var a;
+console.log(a);                // scrive in console "undefined" o "" a seconda del browser usato.
+console.log('still going...'); // scrive in console "still going...".
+ +

3. Variabili dichiarate diventano una proprietà non configurabile del loro contesto di esecuzione (funzione o globale). Quelle non dichiarate sono configurabili (per esempio, possono essere cancellate).

+ +
var a = 1;
+b = 2;
+
+delete this.a; // Genera un TypeError in strict mode. Altrimenti fallisce senza generare messaggi.
+delete this.b;
+
+console.log(a, b); // Genera un ReferenceError.
+// La proprietà 'b' è stata cancellata e non esiste più.
+ +

A causa di queste tre differenze, il fallimento della dichiarazione di variabile porta molto probabilmente a risultati inaspettati. Pertanto è raccomandato di dichiarare sempre le variabili, indipendentemente dal loro contesto di appartenenza (funzione o globale). In ECMAScript 5 strict mode, assegnare una variabile non dichiarata genera un errore.

+ +

Hoisting di var

+ +

Poichè le dichiarazioni di variabile (come le dichiarazioni in generale) sono processate prima dell'esecuzione del codice, dichiararne una in qualsiasi punto del codice è equivalente al dichiararle in cima. Questo significa anche che quella variabile può essere usata prima della dichiarazione. Questo comportamento è chiamato "hoisting" (sollevamento, innalzamento), poichè sembra che la dichiarazione di variabile sia portata in cima alla funzione o al codice globale.

+ +
bla = 2;
+var bla;
+// ...
+
+// è implicitamente interpretato come:
+
+var bla;
+bla = 2;
+
+ +

Per questa ragione, è consigliato sempre dichiarare le variabili in cima al loro ambiente (in cima al codice globale o della funzione in cui appaiono) al fine di rendere chiaro quali variabili appartengono alle funzioni (locali) e quali no.

+ +

È importante precisare che l'hoisting è applicato alla dichiarazione della variabile, ma non all'inizializzazione del suo valore. Il valore verrà infatti assegnato al raggiungimento della dichiarazione :

+ +
function fai_qualcosa() {
+  console.log(bar); // non definito
+  var bar = 111;
+  console.log(bar); // 111
+}
+
+// è implicitamente interpretato come:
+function fai_qualcosa() {
+  var bar;
+  console.log(bar); // non definito
+  bar = 111;
+  console.log(bar); // 111
+}
+
+ +

 

+ +

Esempi

+ +

Dichiarare e inizializzare due variabili

+ +
var a = 0, b = 0;
+
+ +

Assegnare un singolo valore stinga a due variabili

+ +
var a = 'A';
+var b = a;
+
+// è come dire:
+
+var a, b = a = 'A';
+
+ +

Prestare attenzione all'ordine:

+ +
var x = y, y = 'A';
+console.log(x + y); // non definito
+
+ +

Qui, x e y sono dichiarate prima dell'esecuzione del codice, gli assegnamenti verranno eseguiti in seguito. Nel momento in cui "x = y" viene valutato, y esiste quindi nessun ReferenceError viene generato e il suo valore risulta essere 'undefined' (non definit). Quindi, x è assegnata ad un valore non definito. Ora, ad y è assegnato il valore 'A'. Di conseguenza, dopo la prima riga, x === undefined && y === 'A'. Da qui il risultato.

+ +

Inizializzazione di più variabili

+ +
var x = 0;
+
+function f() {
+  var x = y = 1; // x è dichiarata localmente. y invece no!
+}
+f();
+
+console.log(x, y); // Genera un ReferenceError in strict mode (y non è definita). 0, 1 altrimenti.
+// In modalità non-strict mode:
+// x è la globale come si ci aspettava
+// però, y è uscita fuori dalla funzione!
+ +

Globali implicite e ambienti esterni alle funzioni

+ +

Le variabili che sembrano essere globali implicite possono essere riferimenti a variabili nell'ambito di una funzione esterna:

+ +
var x = 0;  // x è dichiarata dentro l'ambiente file, poi le è assegnato valore 0
+
+console.log(typeof z); // undefined, poichè z ancora non esiste
+
+function a() { // quando a è chiamata,
+  var y = 2;   // y è dichiarata dentro l'ambiente della funzione a, e le è assegnato valore 2
+
+  console.log(x, y);   // 0 2
+
+  function b() {       // quando b è chiamata
+    x = 3;  // assegna 3 all'esistente ambiente x, non crea una nuova variabile globale
+    y = 4;  // assegna 4 all'esistente esterna y, non crea una nuova variabile globale
+    z = 5;  // crea una nuova variabile globale z e le assegna valore 5.
+  }         // (Throws a ReferenceError in strict mode.)
+
+  b();     // chiamare b crea z come variabile globale
+  console.log(x, y, z);  // 3 4 5
+}
+
+a();                   // chiamando a si richiama b
+console.log(x, z);     // 3 5
+console.log(typeof y); // non definito, perchè y è locale alla funzione a
+ +

Specifiche

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificaStatoCommento
{{SpecName('ES1')}}{{Spec2('ES1')}}Definizione iniziale, implementata in JavaScript 1.0
{{SpecName('ES5.1', '#sec-12.2', 'var statement')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-variable-statement', 'variable statement')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-variable-statement', 'variable statement')}}{{Spec2('ESDraft')}} 
+ +

Compatibilità Browser

+ + + +

{{Compat("javascript.statements.var")}}

+ +

Guarda anche

+ + -- cgit v1.2.3-54-g00ecf