Dichiarazione di funzione come var al posto di function

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 si finisce per usare il primo, vorrei strongmente suggerire di nominare la funzione:

var foo = function MY_function() {} . Questa convenzione di denominazione aiuta il tuo debugger callstack a non essere inutile.

espressione della funzione:

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

L'espressione func in questo caso è anonimo ma assegnata a una var come riferimento. Questo è diverso da una dichiarazione di funzione etichettata nei seguenti modi:

• non può essere issato (chiamato prima che sia definito)
• % istanze dinew someFunction().constructor.name === 'someFunction';//false 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 una dichiarazione 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 c'è davvero una grande ragione per fare un'espressione su var a meno che tu non voglia che le chiamate falliscano se le cose vengono spostate o stai definendo / assegnando un metodo in una riga. Trovo effettivamente utile il sollevamento per organizzare gli oggetti con le funzioni interne e le definizioni dei metodi in fondo, in modo tale da ottenere il comportamento effettivo dell'oggetto e creare definizioni di un metodo pubblico a una sola riga (assegnando semplicemente funzioni a this. con lo stesso nome) tutto in un unico posto per facilità di consultazione. Dovresti sempre provare a utilizzare istruzioni etichettate per 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 è una istruzione . La definizione di funzioni come espressioni consente una maggiore flessibilità in cui può avvenire la definizione, a cosa è possibile assegnarla, che è possibile passarla come parametro, ecc ...

Ad esempio:

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

vs ...

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

SomeThing('abc', tmp);

Gli esempi più complessi diverrebbero eccessivamente complicati senza la sintassi dell'espressione di funzione.

Guarda link

La principale differenza pratica è il sollevamento. Ad 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 non definito

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

mentre questo è ok.

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