Aquí hay dos formas de escribir una función que incluye un IIFE:
function f() { let count=0; return function() { return ++count; } } const g = (function() { let count=0; return function() { return ++count; } })(); f () devuelve function () { return ++count; }
Cuando g() se ejecuta varias veces, devuelve 1, 2, 3... que es la intención.
Ahora otro ejemplo:
function f() { return "This is f()"; } const g = (function() { return "This is g()"; })();En este caso, f() devuelve "Esto es f()" y g() es un error de script.
He hecho mucha codificación en lenguajes C-ish, pero soy nuevo en JavaScript. ¿Qué me estoy perdiendo?
En respuesta a la primera respuesta, aquí hay un fragmento de código ejecutable. Si function f(){...} fuera lo mismo que const f = (function () {...})() , esperaría que ambos se ejecutaran. Ellos no.
function f() { return "This is f()!"; } console.log(f()); const h = f; console.log(h()); const g = (function() { return "This is g()"; })(); console.log(g());Las funciones en JavaScript son objetos de primera clase , lo que significa que puede tratarlas como cualquier otro objeto en JavaScript.
function f (){} es una definición de función regular, que también puede escribir como
let f = function(){} (function{})() es básicamente lo mismo que
let f = function () {} f = f() // You reassign f to be the return value from the function that f was assigned to Tu fondo de caja const g = (function() {return "This is g()";})(); Se puede escribir como:
let g = function() { return "This is g()" } g = g() // You are reassigning g to be "This is g()" // Trying to call g again is like calling a string // and it should return an error saying that g is not a function g() La diferencia en su ejemplo extendido es que f es una función que devuelve una función (siempre), mientras que g se asigna inmediatamente a la "función regular" interna y devuelve números.
function f() { let count = 0; // --- Will always return this, a function ---- return function () { return ++count; } // -------------------------------------------- } const g = (function () { let count = 0; return function () { return ++count; } })() // <--- Here you call the (function () {}) immediately, thus you assign g to the inner returned function console.log(f); console.log(f()); // returns a function console.log(g); console.log(g()); // returns a number console.log(g()); console.log(g()); console.log(g()); Para hacer f equivalente a g tienes que hacer esto:
function f() { let count = 0; return function () { return ++count; } } f = f() // HereEl comportamiento del siguiente recorte aclara mi pregunta...
Y creo que veo la respuesta. En el primer caso, f() no hace nada hasta que se llama. Y cuando se llama, devuelve la cadena.
En el segundo caso, (function(){})() se ejecuta inmediatamente y devuelve la función misma.
Como su nombre lo dice, ejecución inmediata. Gracias por ayudarme a hacer la pregunta correcta.
function f() { let count=0; return function() { return ++count; } } const g = (function() { let count=0; return function() { return ++count; } })(); console.log(f); console.log(f()); console.log(g); console.log(g()); console.log(g()); console.log(g()); console.log(g());