Explain how this function works [closed]

It's a function which, inside, calls an immediately-invoked function expression (IIFE) - i.e. a function that is declared and called in the same line.

The return does nothing (it returns the return value from the alert(), which is undefined; nothing is listening for the return.)

Both the outer function and the IIFE use what's called arrow functions - short-syntax functions that don't have their own this context.

The whole thing could be reduced to simply:

let a = () => alert('hello'); a(); 

(b) => alert(b) is an arrow function

((b) => alert(b)) our arrow function is actually an anonymous function expression, and we need to wrap it between parentheses in order to invoke it in place

((b) => alert(b))("hello") we pass "hello" as an argument to our function when invoking it

() => { return ... } is yet another anonymous arrow function, except this time, instead of invoking the function in place, we store in a variable named a so that we can invoke it later

a() calls the previously stored function, which in turn calls (b) => alert(b) with the argument "hello" which in turn calls alert("hello")

Let's focus on the

((b) => alert(b))("hello"); 

first. ((b) => alert(b)) is a function that take a parameter b, and return alert(b). And the ("hello") here, is a parameter that is send to this function.

Soo, about this whole expression. I can present another form that'll work

let a = () => { ((b) => alert(b)) ("hi") } a() 

here you don't even have to have a return. Alert return nothing anyway. So basically, in this block, you define a function a, that take no parameters, and execute the code that i already explained.

Arrow functions: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions

IIFE: https://developer.mozilla.org/en-US/docs/Glossary/IIFE

Same as

let a = () => { return ((b) => alert(b))("hello"); }; a(); 

a is a named function let a =

a is an arrow function () => {}

a is a parameter-less arrow function since the parenthesis is empty ()

((b) => alert(b))("hello"); is an immediately invoked function since it is inside the ()

(b) => alert(b) is an arrow function with parameter b that alerts the b value

((b) => alert(b))("hello"); gets the value "hello" since the ("hello") passes the immediately invoked function using that value as the parameter value for b

So given all that, let's see some examples:

let a = () => { return ((b) => alert(b))("hello"); }; a(); // same net effect ((b) => alert(b))("hellos"); // same net effect alert("hellosa"); (function(x){alert(x)})("hello Me") // https://developer.mozilla.org/en-US/docs/Glossary/IIFE let af = function() { return ((b) => alert(b))("helloaf"); }; af(); let na = function(nb) { return ((b) => alert(b))(nb); }; na("hellob"); let nab = function(nbb) { return function(bi){alert(bi);}(nbb); }; nab("hellobb"); function nab2(nbb) { return function(bi){alert(bi);}(nbb); }; nab2("hello2"); /* two functions */ function sayHi(bi){ alert(bi); } function nab3(nbbn) { return sayHi(nbbn); }; nab3("hello3");