var

Sintaxis

var nombreDeVariable1 [= valor1] [, nombreDeVariable2 [= valor2] ... [, nombreDeVariableN [=valorN]]];

nombreDeVariableN

Representa el nombre que el programador da a la variable. Puede ser cualquier identificador legal.

valorN

Valor inicial de la variable. Puede ser cualquier expresin legal. El valor predeterminado es undefined (en espaol, indefinida).

Descripcin

Las declaraciones de variables, donde sea que ocurran, son procesadas antes de que cualquier otro cdigo sea ejecutado. El mbito de una variable declarada con la palabra reservada var es su contexto de ejecucin en curso*,* que puede ser la funcin que la contiene o, para las variables declaradas afuera de cualquier funcin, un mbito global. Si re-declaras una variable Javascript, esta no perder su valor.

Asignar un valor a una variable no declarada implica crearla como variable global (se convierte en una propiedad del objeto global) cuando la asignacin es ejecutada. Las diferencias entre una variable declarada y otra sin declarar son:

1. Las variables declaradas se limitan al contexto de ejecucin en el cual son declaradas. Las variables no declaradas siempre son globales.

function x() {
  y = 1; // Lanza un error de tipo "ReferenceError" en modo estricto ('use strict')
  var z = 2;
}

x();

console.log(y); // Imprime "1"
console.log(z); // Lanza un error de tipo "ReferenceError": z no est definida afuera de x

2. Las variables declaradas son creadas antes de ejecutar cualquier otro cdigo. Las variables sin declarar no existen hasta que el cdigo que las asigna es ejecutado.

console.log(a); // Lanza un error de tipo "ReferenceError".
console.log("trabajando..."); // Nunca se ejecuta.

var a;
console.log(a); // Imprime "undefined" o "" dependiendo del navegador.
console.log("trabajando..."); // Imprime "trabajando...".

3. Las variables declaradas son una propiedad no-configurable de su contexto de ejecucin (de funcin o global). Las variables sin declarar son configurables (p. ej. pueden borrarse).

var a = 1;
b = 2;

delete this.a; // Lanza un error de tipo "ReferenceError" en modo estricto ('use strict'), de lo contrario falla silenciosamente.
delete this.b;

console.log(a, b); // Lanza un error de tipo "ReferenceError".
// La propiedad 'b' se elimin y ya no existe.

Debido a esas tres diferencias, fallar al declarar variables muy probablemente llevar a resultados inesperados. Por tanto se recomienda siempre declarar las variables, sin importar si estn en una funcin o un mbito global. Y en el modo estricto (strict mode) de ECMAScript 5, asignar valor a una variable sin declarar lanzar un error.

Elevacin de variables

Como la declaracin de variables (y todas las declaraciones en general) se procesa antes de ejecutar cualquier cdigo, declarar una variable en cualquier parte del cdigo es equivalente a declararla al inicio del mismo. Esto tambin significa que una variable puede parecer usarse antes de ser declarada. Este comportamiento es llamado hoisting (del ingls "elevacin"), ya que la declaracin de una variable parecer haber sido movida a la cima de la funcin o cdigo global.

bla = 2;
var bla;
// ...

// Es entendido implicitamente como:

var bla;
bla = 2;

Por esa razn, se recomienda siempre declarar variables al inicio de su mbito (la cima del cdigo global y la cima del cdigo de funcin) para que sea claro cules variables pertenecen al mbito de funcin (local) y cules son resueltas en la cadena de mbito.

Es importante sealar que la elevacin afectar la declaracin de variables, pero no su inicializacin. El valor ser asignado precisamente cuando la sentencia de asignacin sea alcanzada:

function haz_algo() {
  console.log(bar); // undefined (valor indefinido)
  var bar = 111;
  console.log(bar); // 111
}

// Se entiende implcitamente como:
function haz_algo() {
  var bar;
  console.log(bar); // undefined (valor indefinido)
  bar = 111;
  console.log(bar); // 111
}

Ejemplos

Declarando e inicializando dos variables

var a = 0,
  b = 0;

Asignando dos variables con un solo valor de cadena

var a = "A";
var b = a;

// Equivalente a:

var a,
  b = (a = "A");

S consciente del orden:

var x = y,
  y = "A";
console.log(x + y); // Imprimir "undefinedA"

Aqu, 'x' & 'y' son declaradas antes de ejecutarse cualquier cdigo, y la asignacin ocurre despus. Al momento de evaluar "x = y", 'y' existe as que ningn error "ReferenceError" es lanzado y su valor es 'undefined', de modo que 'x' tambin tiene asignada el valor 'undefined'. Despus, a 'y' se le asigna el valor 'A'. Consecuentemente, luego de la primera lnea, 'x' es exactamente igual a 'undefined' & 'y' es igual a 'A', de ah el resultado.

Initializacin de muchas variables

var x = 0;

function f() {
  var x = (y = 1); // 'x' es declarada localmente, 'y' no lo es!
}
f();

console.log(x, y); // Lanza un error de tipo "ReferenceError" en modo estricto ('y' no est definida). De lo contrario se imprimira "0, 1".
// En modo no-estricto:
// 'x' es la variable global como se esperara
// 'y' sin embargo, se sale de la funcin

Globales implcitas y mbito externo a una funcin

Las variables que parecen ser globales implcitas pueden ser referencias a variables en un mbito externo a la funcin:

var x = 0; // 'x' es declarada globalmente, luego se le asigna el valor 0.

console.log(typeof z); // Imprime "undefined", pues 'z' an no existe.

function a() {
  // Cuando 'a()' es invocada,
  var y = 2; // 'y' es declarada localmente en la function 'a()', despus se le asigna el valor 2.

  console.log(x, y); // Imprime "0, 2".

  function b() {
    // Cuando 'b()' es invocada,
    x = 3; // Asigna el valor 3 a la global 'x' ya existente, no crea una nueva variable global.
    y = 4; // Asigna 4 a la externa existente 'y', no crea una nueva variable global.
    z = 5; // Crea una nueva variable global 'z' y le asigna un valor de 5.
  } // (Lanza un error de tipo "ReferenceError" en modo estricto.)

  b(); // Invocar 'b()' crea 'z' como variable global.
  console.log(x, y, z); // Imprime "3, 4, 5".
}

a(); // Invocar 'a()' tambin llama a 'b()'.
console.log(x, z); // Imprime "3, 5", porque 'z' ya es una global.
console.log(typeof y); // Imprime 'undefined' porque 'y' es local en la funcin 'a()'