¿ventaja de JavaScript colocando funciones dentro de variables?

Question

He visto ejemplos de códigos recientes que ubican funciones dentro de variables y luego llaman a las funciones como normal.

Como en:

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

myFunctionName(); 

estoy seguro de que hay un montón de ventajas con escenarios más avanzados, pero tengo curiosidad.

Answer 1

No hay ventajas, no está colocando una función dentro de una variable que simplemente está nombrando la función de manera diferente.

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

Estas son exactamente las mismas excepto por una cosa.

Esto funciona:

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

esto no funciona:

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

El intérprete de JavaScript procesamiento previo de los function foo 's antes de ejecutar y empujarlos a la parte superior del programa por lo que son disponible pero no hará eso con var foo = function.

Answer 2

Hay algunas cosas que puede hacer con una expresión de función que no puede con una declaración.

• que podría ser invocada inmediatamente, y el valor de retorno se almacena en la variable

• si no estás en el espacio de nombres global, que podría excluir la palabra clave var para crear un mundial

---

EDIT:

Aquí hay un ejemplo de una invocación inmediata. Devuelve una función a la variable myFunctionName que tiene acceso a las variables y al parámetro delimitado en la función invocada inmediatamente.

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(); 

---

Aquí hay un ejemplo donde una función mantiene un valor numérico. Puede llamar repetidamente a la función y darle un número para agregar al recuento. Siempre hará referencia al valor actual, por lo que cada llamada es acumulativa.

Ejemplo: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

Esto se llama una expresión de función, que tiene un comportamiento ligeramente diferente que una declaración de función. Entre otras cosas, actúa de manera diferente cuando se trata de cuándo puedes consultarlo.Por ejemplo, si lo hace:

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

No se puede llamar o hacer referencia a la función hasta después de que ha sido asignado, mientras que

function myFunctionName() { 
    Code Here... 
} 

se puede denominar de cualquier parte del mismo alcance, incluso antes de que sea declarado. Esto se debe a una característica en Javascript llamada "elevación", donde todas las declaraciones de funciones se mueven a la parte superior del bloque de código detrás de las escenas.

Ver también:

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

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