vantaggio JavaScript posizionando le funzioni all'interno delle variabili?

Question

Ho visto esempi di codice recenti che inseriscono funzioni all'interno di variabili e poi chiamano le funzioni come normali.

Come in:

var myFunctionName = function() { 
    Code Here... 
} 

myFunctionName(); 

Sono sicuro che ci sono un sacco di vantaggi con scenari più avanzati, ma io sono solo curioso.

Answer 1

Non ci sono vantaggi, non si sta inserendo una funzione all'interno di una variabile si sta semplicemente nominando la funzione in modo diverso.

function foo() { /* ... */ } 
var foo = function() { /* ... */ } 

Queste sono esattamente le stesse tranne una cosa.

Questo funziona:

foo("Hello!"); 
/* Later on... */ 
function foo() { /* ... */ } 

Questo non funziona:

foo("Hello!"); 
/* Later on... */ 
var foo = function() { /* ... */ } 

L'interprete JavaScript sarà pre-elaborazione tutti function foo 's prima di eseguire e spingerli verso l'alto del programma in modo che siano disponibile ma non lo farà con lo var foo = function.

Answer 2

Ci sono alcune cose che puoi fare con un'espressione di funzione che non puoi con una dichiarazione.

• potrebbe essere immediatamente richiamato, e il valore di ritorno memorizzato se non sei nel namespace globale nella variabile

• , si potrebbe escludere la parola chiave var per creare un globale

---

EDIT:

Ecco un esempio di una chiamata immediata. Restituisce una funzione alla variabile myFunctionName che ha accesso alle variabili e al parametro con scope nella funzione immediatamente richiamata.

var myFunctionName = function(v) { 
     // do something with "v" and some scoped variables 
     // return a function that has access to the scoped variables 

    return function() { 
     // this function does something with the scoped variables 
    }; 
}('someVal'); 

    // now this function is the only one that has access 
    // to the variables that were scoped in the outer expression. 
myFunctionName(); 

---

Ecco un esempio in cui una funzione mantiene un valore numerico. Puoi chiamare ripetutamente la funzione, dandole un numero da aggiungere al conteggio. Farà sempre riferimento al valore corrente, quindi ogni chiamata è cumulativa.

Esempio:http://jsfiddle.net/5uuLa/1/

var counter = function(value) { 

    return function(addValue) { 
     value += ~~addValue; 
     return value; 
    }; 
}(10); // initialize with a value 

    // each call builds on the result of the previous  
console.log(counter(2)); // 12 
console.log(counter(5)); // 17 
console.log(counter(3)); // 20 
console.log(counter(7)); // 27 
console.log(counter(1)); // 28 

Answer 3

Questo è chiamato un espressione di funzione, che ha un comportamento leggermente diverso da una dichiarazione di funzione. Tra le altre cose, agisce in modo diverso quando si può fare riferimento ad esso.Per esempio, se si fa:

var myFunctionName = function() { 
    Code Here... 
} 

Non è possibile chiamare o fare riferimento alla funzione solo dopo è stato assegnato, mentre

function myFunctionName() { 
    Code Here... 
} 

può essere riferito a qualsiasi punto della stessa portata, anche prima che sia dichiarato. Ciò è dovuto a una funzione in Javascript chiamata "sollevamento", in cui tutte le dichiarazioni di funzioni vengono spostate nella parte superiore del blocco di codice dietro le quinte.

Vedere anche:

What is the difference between a function expression vs declaration in JavaScript?

http://www.adequatelygood.com/2010/2/JavaScript-Scoping-and-Hoisting