Declaração de função como var em vez de função

Mais e mais eu estou vendo funções sendo declaradas como

var foo = function() {

    // things
};

Em vez de como eu aprendi, como

function foo() {

    // things
}

Qual é a diferença? Melhor performance? Escopo? Devo estar usando esse método?

var foo = function() {} define uma variável que referencia uma função anônima.

function foo() {}define uma função nomeada foo.

Qualquer um pode ser passado pelo nome como parâmetros de função e pode ser instanciado se o uso pretendido for para OOP.

No final do dia, qual você usa é amplamente determinado pelo seu caso de uso específico (o Javascript é divertido assim;)). Se você acabar usando o primeiro, sugiro fortemente que você nomeie a função:

var foo = function MY_function() {}. Essa convenção de nomenclatura ajuda o callstack do depurador a não ser inútil.

expressão de função:

//someFunction(); //wouldn't work when uncommented
var someFunction = function(){ alert('yay'); };

A expressão func neste caso é anônima, mas atribuída a um var para referência. Isso é diferente de uma instrução de função rotulada das seguintes maneiras:

• não pode ser içado (chamado antes de ser definido)
• new someFunction().constructor.name === 'someFunction';//false As instâncias não obtêm o nome do var para constructor.name porque uma referência à função é atribuída ao var, mas o var, não a função, está vinculado ao nome do var

Em uma instrução de função rotulada:

//someFunction(); //works when uncommented
function someFunction(){ alert('yay'); }

• trabalhos de elevação
• new someFunction().constructor.name === 'someFunction'; //true o nome está vinculado diretamente à função.

De um modo geral, não há realmente nenhuma grande razão para fazer expressão para var, a menos que você queira que as chamadas falhem se as coisas mudam ou você está definindo / atribuindo um método em uma linha. Na verdade, considero a elevação útil para organizar objetos com definições internas de função e método na parte inferior, para que eu possa entender o comportamento real do objeto e fazer definições de método público de uma linha (apenas atribuindo funcs ao this.mesmo nome), tudo em um local para facilitar a referência. Você deve sempre tentar usar instruções rotuladas para construtores, IMO, para poder identificar o 'tipo' de um objeto por meio de seu construtor.

Seu primeiro exemplo é uma expressão, enquanto o segundo exemplo é uma declaração . A definição de funções como expressões permite mais flexibilidade no local em que a definição pode ocorrer, no que você pode atribuí-la, que pode ser transmitida como parâmetro, etc.

Por exemplo:

SomeThing('abc', function(a,b) {return a*b;});

vs ...

function tmp(a,b) { 
    return a*b;
}

SomeThing('abc', tmp);

Exemplos mais complexos se tornariam obcenamente complicados sem a sintaxe da expressão da função.

Veja /programming/111102/how-do-javascript-closures-work

A principal diferença prática é a elevação. Por exemplo:

foo(); // alerts 'hello'
function foo() {alert('hello');}

vs

foo(); // throws an error since foo is undefined
var foo = function() {alert('hello');}

Além disso, esse é um comportamento indefinido

function foo(){
  if (true) {
    function bar(){}
  }
  bar();
}

enquanto isso estiver ok.

function foo(){
  if (true) {
    var bar = function(){}
  }
  bar();
}