Questa traduzione è incompleta. Collabora alla traduzione di questo articolo dall’originale in lingua inglese.

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

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 Latest Draft (ECMA-262)
The definition of 'variable statement' in that specification.
Draft  

Compatibilità Browser

Update compatibility data on GitHub
DesktopMobileServer
ChromeEdgeFirefoxInternet ExplorerOperaSafariAndroid webviewChrome for AndroidEdge MobileFirefox for AndroidOpera for AndroidiOS SafariSamsung InternetNode.js
Basic supportChrome Full support YesEdge Full support YesFirefox Full support 1IE Full support YesOpera Full support YesSafari Full support YesWebView Android Full support YesChrome Android Full support YesEdge Mobile Full support YesFirefox Android Full support 4Opera Android Full support YesSafari iOS Full support YesSamsung Internet Android Full support Yesnodejs Full support Yes

Legend

Full support  
Full support

Guarda anche

Tag del documento e collaboratori

Hanno collaborato alla realizzazione di questa pagina: IkobaNoOkami
Ultima modifica di: IkobaNoOkami,