La dichiarazione variabile
dichiara una variabile, opzionalmente inizializzabile ad un valore.
The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request.
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
Specifica | Stato | Commento |
---|---|---|
ECMAScript 1st Edition (ECMA-262) | Standard | Definizione iniziale, implementata in JavaScript 1.0 |
ECMAScript 5.1 (ECMA-262) The definition of 'var statement' in that specification. |
Standard | |
ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'variable statement' in that specification. |
Standard | |
ECMAScript (ECMA-262) The definition of 'variable statement' in that specification. |
Living Standard |
Compatibilità Browser
BCD tables only load in the browser