Dichiarazione di funzione come var anziché funzione

Sempre più vedo che le funzioni vengono dichiarate come

var foo = function() {

    // things
};

Invece di come avevo imparato, mi piace

function foo() {

    // things
}

Qual è la differenza? Prestazioni migliori? Scopo? Dovrei usare questo metodo?

var foo = function() {} definisce una variabile che fa riferimento a una funzione anonima.

function foo() {}definisce una funzione denominata foo.

Entrambi possono essere passati per nome come parametri di funzione e possono essere istanziati se l'uso previsto è per OOP.

Alla fine della giornata, quello che usi è in gran parte dettato dal tuo caso d'uso specifico (Javascript è divertente così;)). Se finisci per usare il primo, ti consiglio vivamente di nominare la funzione:

var foo = function MY_function() {}. Questa convenzione di denominazione consente al callstack del debugger di non essere inutile.

espressione di funzione:

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

L'espressione func in questo caso è anonima ma assegnata a var per riferimento. Ciò è diverso da un'istruzione di funzione etichettata nei seguenti modi:

• non può essere sollevato (chiamato prima che sia definito)
• new someFunction().constructor.name === 'someFunction';//false le istanze non ottengono il nome var per constructor.name perché un riferimento alla funzione è assegnato a var ma var, non la funzione, è legato al nome var

In un'istruzione di funzione etichettata:

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

• lavori di sollevamento
• new someFunction().constructor.name === 'someFunction'; //true il nome è legato direttamente alla funzione.

In generale, non esiste davvero alcun motivo valido per fare espressione su var a meno che non si desideri che le chiamate falliscano se le cose vengono spostate o si sta definendo / assegnando un metodo su una riga. In realtà trovo utile il sollevamento per organizzare gli oggetti con definizioni interne di funzioni e metodi nella parte inferiore in modo da poter arrivare al comportamento reale dell'oggetto e fare definizioni di metodi pubblici di una riga (assegnando semplicemente funzioni a this.con lo stesso nome) tutto in uno spot per facilità di riferimento. Dovresti sempre provare a usare le istruzioni etichettate per i costruttori, IMO, in modo da poter identificare il 'tipo' di un oggetto tramite il suo costruttore.

Il tuo primo esempio è un'espressione mentre il secondo esempio è un'istruzione . La definizione di funzioni come espressioni consente una maggiore flessibilità in cui può verificarsi la definizione, a cosa è possibile assegnarla, che è possibile passarla come parametro, ecc.

Per esempio:

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

vs ...

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

SomeThing('abc', tmp);

Esempi più complessi diventerebbero oscenamente complicati senza la sintassi dell'espressione della funzione.

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

La principale differenza pratica è il sollevamento. Per esempio:

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

vs

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

Inoltre, questo è un comportamento indefinito

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

mentre questo va bene.

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