NOTA : Esta pergunta foi feita do ponto de vista da versão 3 ou 5. do ECMAScript. As respostas podem ficar desatualizadas com a introdução de novos recursos na versão do ECMAScript 6.

Qual é exatamente a função da varpalavra - chave em JavaScript e qual é a diferença entre

var someNumber = 2;
var someFunction = function() { doSomething; }
var someObject = { }
var someObject.someProperty = 5;

e

someNumber = 2;
someFunction = function() { doSomething; }
someObject = { }
someObject.someProperty = 5;

?

Quando você usaria um deles e por que / o que ele faz?

Se você está no escopo global, não há muita diferença. Leia a resposta de Kangax para explicação

Se você estiver em uma função, varcriará uma variável local, "no var" pesquisará a cadeia de escopo até encontrar a variável ou atingir o escopo global (no momento em que a criará):

// These are both globals
var foo = 1;
bar = 2;

function()
{
    var foo = 1; // Local
    bar = 2;     // Global

    // Execute an anonymous function
    (function()
    {
        var wibble = 1; // Local
        foo = 2; // Inherits from scope above (creating a closure)
        moo = 3; // Global
    }())
}

Se você não estiver realizando uma tarefa, precisará usar var:

var x; // Declare x

Há uma diferença .

var x = 1 declara variável x no escopo atual (também conhecido como contexto de execução). Se a declaração aparecer em uma função - uma variável local é declarada; se estiver no escopo global - uma variável global é declarada.

x = 1, por outro lado, é apenas uma atribuição de propriedade. Primeiro, ele tenta resolver com xrelação à cadeia de escopo. Se o encontrar em qualquer lugar dessa cadeia de escopo, ele executará a atribuição; se não encontrar x, somente cria xpropriedade em um objeto global (que é um objeto de nível superior em uma cadeia de escopo).

Agora, observe que ela não declara uma variável global, ela cria uma propriedade global.

A diferença entre os dois é sutil e pode ser confusa, a menos que você entenda que as declarações de variáveis ​​também criam propriedades (apenas em um objeto variável) e que todas as propriedades em Javascript (bem, ECMAScript) possuem determinados sinalizadores que descrevem suas propriedades - ReadOnly, DontEnum e Não exclua.

Como a declaração de variável cria propriedade com o sinalizador DontDelete, a diferença entre var x = 1e x = 1(quando executada no escopo global) é que a primeira - declaração de variável - cria a propriedade DontDelete'able, e a segunda não. Como conseqüência, a propriedade criada por meio dessa atribuição implícita pode ser excluída do objeto global e a anterior - a criada por meio da declaração de variável - não pode ser excluída.

Mas isso é apenas teoria, é claro, e na prática há ainda mais diferenças entre os dois , devido a vários erros nas implementações (como as do IE).

Espero que tudo faça sentido :)

[Atualização 16/12/2010]

No ES5 (ECMAScript 5; recentemente padronizado, 5ª edição do idioma), existe o chamado "modo estrito" - um modo de idioma de aceitação, que altera levemente o comportamento de atribuições não declaradas. No modo estrito, a atribuição a um identificador não declarado é um ReferenceError . A lógica para isso era capturar atribuições acidentais, impedindo a criação de propriedades globais indesejadas. Alguns dos navegadores mais recentes já começaram a rolar o suporte ao modo estrito. Veja, por exemplo, minha tabela compat .

Dizer que é a diferença entre " local e global " não é totalmente preciso.

Talvez seja melhor pensar nisso como a diferença entre " local e mais próximo ". O mais próximo certamente pode ser global, mas nem sempre será esse o caso.

/* global scope */
var local = true;
var global = true;

function outer() {
    /* local scope */
    var local = true;
    var global = false;

    /* nearest scope = outer */
    local = !global;

    function inner() {
        /* nearest scope = outer */
        local = false;
        global = false;

        /* nearest scope = undefined */
        /* defaults to defining a global */
        public = global;
    }
}

Quando o Javascript é executado em um navegador, todo o seu código é cercado por uma declaração with, assim:

with (window) {
    //Your code
}

Mais informações sobre with- MDN

Como vardeclara uma variável no escopo atual , não há diferença entre declarar var dentro da janela e nem mesmo declará-la.

A diferença ocorre quando você não está diretamente dentro da janela, por exemplo, dentro de uma função ou dentro de um bloco.

Usar varpermite ocultar variáveis ​​externas com o mesmo nome. Dessa maneira, você pode simular uma variável "privada", mas esse é outro tópico.

Uma regra prática é sempre usar var, porque, caso contrário, você corre o risco de introduzir bugs sutis.

EDIT: Após as críticas que recebi, gostaria de enfatizar o seguinte:

• vardeclara uma variável no escopo atual
• O escopo global é window
• Não usar vardeclarações implícitas varno escopo global (janela)
• Declarar uma variável no escopo global (janela) usando varé o mesmo que omiti-la.
• Declarar uma variável em escopos diferentes da janela usando var não é a mesma coisa que declarar uma variável semvar
• Sempre declare varexplicitamente porque é uma boa prática

Sempre use a varpalavra-chave para declarar variáveis. Por quê? A boa prática de codificação deve ser uma razão suficiente, mas omití-la significa que ela é declarada no escopo global (uma variável como essa é chamada de global "implícita"). Douglas Crockford recomenda nunca usar globals implícitas e de acordo com as Diretrizes de codificação da Apple JavaScript :

Qualquer variável criada sem a var palavra-chave é criada no escopo global e não é coletada como lixo quando a função retorna (porque ela não sai do escopo), apresentando a oportunidade para um vazamento de memória.

Aqui está um bom exemplo de como você pode ser pego por não declarar variáveis ​​locais com var:

<script>
one();

function one()
{
    for (i = 0;i < 10;i++)
    {
        two();
        alert(i);
    }
}

function two()
{
    i = 1;
}
</script>

( ié redefinido a cada iteração do loop, pois não é declarado localmente no forloop, mas globalmente) eventualmente resultando em loop infinito

Eu diria que é melhor usar varna maioria das situações.

As variáveis ​​locais são sempre mais rápidas que as variáveis ​​no escopo global.

Se você não vardeclarar uma variável, ela estará no escopo global.

Para mais informações, você pode pesquisar "JavaScript da cadeia de escopo" no Google.

Não use var!

varfoi a maneira pré-ES6 de declarar uma variável. Estamos agora no futuro e você deve codificar como tal.

Use constelet

constdeve ser usado em 95% dos casos. Isso faz com que a referência da variável não possa ser alterada, portanto, as propriedades da matriz, objeto e nó do DOM podem ser alteradas e provavelmente deveriam ser const.

letdeve ser usado para qualquer variável que espera ser reatribuída. Isso inclui um loop for. Se você escrever varName =além da inicialização, use let.

Ambos têm escopo no nível do bloco, como esperado na maioria dos outros idiomas.

outra diferença, por exemplo

var a = a || [] ; // works 

enquanto

a = a || [] ; // a is undefined error.

O uso varé sempre uma boa idéia para impedir que as variáveis ​​atrapalhem o escopo global e as variáveis ​​entrem em conflito umas com as outras, causando substituição indesejada.

Sem var- variável global.

Altamente recomendado para sempre usar vardeclaração, porque init variável global no contexto local - é mau. Mas, se você precisar desse truque sujo, escreva um comentário no início da página:

/* global: varname1, varname2... */

Este é um código de exemplo que escrevi para você entender esse conceito:

var foo = 5; 
bar = 2;     
fooba = 3;

// Execute an anonymous function
(function() {    
    bar = 100;             //overwrites global scope bar
    var foo = 4;           //a new foo variable is created in this' function's scope
    var fooba = 900;       //same as above
    document.write(foo);   //prints 4
    document.write(bar);   //prints 100
    document.write(fooba); //prints 900
})();

document.write('<br/>');
document.write('<br/>');
document.write(foo);       //prints 5
document.write(bar);       //prints 100
document.write(fooba);     //prints 3

@ Chris S deu um bom exemplo, mostrando a diferença prática (e o perigo) entre vare não var. Aqui está outro, acho este particularmente perigoso, porque a diferença é visível apenas em um ambiente assíncrono, para que ele possa passar facilmente durante o teste.

Como seria de esperar, as seguintes saídas de snippet ["text"]:

function var_fun() {
  let array = []
  array.push('text')
  return array
}

console.log(var_fun())

O mesmo acontece com o seguinte trecho (observe o que faltava letantes array):

function var_fun() {
  array = []
  array.push('text')
  return array
}

console.log(var_fun())

A execução da manipulação de dados de forma assíncrona ainda produz o mesmo resultado com um único executor:

function var_fun() {
  array = [];
  return new Promise(resolve => resolve()).then(() => {
    array.push('text')
    return array
  })
}

var_fun().then(result => {console.log(result)})

Mas se comporta de maneira diferente com vários:

function var_fun() {
  array = [];
  return new Promise(resolve => resolve()).then(() => {
    array.push('text')
    return array
  })
}

[1,2,3].forEach(i => {
  var_fun().then(result => {console.log(result)})
})

No entanto, usando let:

function var_fun() {
  let array = [];
  return new Promise(resolve => resolve()).then(() => {
    array.push('text')
    return array
  })
}

[1,2,3].forEach(i => {
  var_fun().then(result => {console.log(result)})
})

Como alguém tentando aprender isso, é assim que eu vejo. Os exemplos acima foram talvez um pouco complicados demais para um iniciante.

Se você executar este código:

var local = true;
var global = true;


function test(){
  var local = false;
  var global = false;
  console.log(local)
  console.log(global)
}

test();

console.log(local);
console.log(global);

A saída será lida como: false, false, true, true

Como ele vê as variáveis ​​na função separadas daquelas fora dela, daí o termo variável local e isso ocorreu porque usamos var na atribuição. Se você remover o var na função, ele ficará assim:

var local = true;
var global = true;


function test(){
  local = false;
  global = false;
  console.log(local)
  console.log(global)
}

test();

console.log(local);
console.log(global);

A saída é falsa, falsa, falsa, falsa

Isso ocorre porque, em vez de criar uma nova variável no escopo ou função local, ela simplesmente usa as variáveis ​​globais e as atribui novamente a false.

Eu vejo pessoas confusas ao declarar variáveis ​​com ou sem var e dentro ou fora da função. Aqui está um exemplo profundo que o guiará através destas etapas:

Veja o script abaixo em ação aqui em jsfiddle

a = 1;// Defined outside the function without var
var b = 1;// Defined outside the function with var
alert("Starting outside of all functions... \n \n a, b defined but c, d not defined yet: \n a:" + a + "\n b:" + b + "\n \n (If I try to show the value of the undefined c or d, console.log would throw 'Uncaught ReferenceError: c is not defined' error and script would stop running!)");

function testVar1(){
    c = 1;// Defined inside the function without var
    var d = 1;// Defined inside the function with var
    alert("Now inside the 1. function: \n a:" + a + "\n b:" + b + "\n c:" + c + "\n d:" + d);

    a = a + 5;
    b = b + 5;
    c = c + 5;
    d = d + 5;

    alert("After added values inside the 1. function: \n a:" + a + "\n b:" + b + "\n c:" + c + "\n d:" + d);
};


testVar1();
alert("Run the 1. function again...");
testVar1();

function testVar2(){
    var d = 1;// Defined inside the function with var
    alert("Now inside the 2. function: \n a:" + a + "\n b:" + b + "\n c:" + c + "\n d:" + d);

    a = a + 5;
    b = b + 5;
    c = c + 5;
    d = d + 5;

    alert("After added values inside the 2. function: \n a:" + a + "\n b:" + b + "\n c:" + c + "\n d:" + d);
};

testVar2();

alert("Now outside of all functions... \n \n Final Values: \n a:" + a + "\n b:" + b + "\n c:" + c + "\n You will not be able to see d here because then the value is requested, console.log would throw error 'Uncaught ReferenceError: d is not defined' and script would stop. \n ");
alert("**************\n Conclusion \n ************** \n \n 1. No matter declared with or without var (like a, b) if they get their value outside the function, they will preserve their value and also any other values that are added inside various functions through the script are preserved.\n 2. If the variable is declared without var inside a function (like c), it will act like the previous rule, it will preserve its value across all functions from now on. Either it got its first value in function testVar1() it still preserves the value and get additional value in function testVar2() \n 3. If the variable is declared with var inside a function only (like d in testVar1 or testVar2) it will will be undefined whenever the function ends. So it will be temporary variable in a function.");
alert("Now check console.log for the error when value d is requested next:");
alert(d);

Conclusão

1. Não importa se declarado com ou sem var (como a, b), se eles obtiverem seu valor fora da função, eles preservarão seu valor e também quaisquer outros valores adicionados dentro de várias funções através do script serão preservados.
2. Se a variável for declarada sem var dentro de uma função (como c), ela atuará como a regra anterior, preservando seu valor em todas as funções a partir de agora. Ou ele obteve seu primeiro valor na função testVar1 (), ainda preserva o valor e obtém valor adicional na função testVar2 ()
3. Se a variável for declarada com var apenas dentro de uma função (como d em testVar1 ou testVar2), ela será indefinida sempre que a função terminar. Portanto, será uma variável temporária em uma função.

Dentro de um código, se você usa uma variável sem usar var, o que acontece é que o var_name automaticamente é colocado no escopo global, por exemplo:

someFunction() {
    var a = some_value; /*a has local scope and it cannot be accessed when this
    function is not active*/
    b = a; /*here it places "var b" at top of script i.e. gives b global scope or
    uses already defined global variable b */
}

Além da questão dos escopos, algumas pessoas também mencionam a elevação , mas ninguém deu um exemplo. Aqui está um para o escopo global:

console.log(noErrorCase);
var noErrorCase = "you will reach that point";

console.log(runTimeError);
runTimeError = "you won't reach that point";

Sem o uso de "var", as variáveis ​​só podem definir quando definir um valor. No exemplo:

my_var;

não pode funcionar no escopo global ou em qualquer outro escopo . Deve ser com valor como:

my_var = "value";

Por outro lado, você pode definir um tipo disponível;

var my_var;

Seu valor é undefined(seu valor não é nulle não é igual a nullinteressante).

Você deve usar a palavra-chave var, a menos que pretenda ter a variável anexada ao objeto de janela no navegador. Aqui está um link que explica o escopo e a diferença entre o escopo glocal e o local com e sem a palavra-chave var.

Quando as variáveis ​​são definidas sem o uso da palavra-chave var, o que parece é uma operação simples de "atribuição".

Quando o valor é atribuído a uma variável em javascript, o intérprete tenta primeiro encontrar a “declaração de variável” no mesmo contexto / escopo que o da atribuição. Quando o intérprete é executado dummyVariable = 20, ele procura a declaração de dummyVariable no início da função. (Como todas as declarações de variáveis ​​são movidas para o início do contexto pelo interpretador javascript e isso é chamado de içamento)

Você também pode querer considerar içar em javascript