CH. 04.5 Anonymous Functions and Closures [JS Tutorial]

Anonymous Functions

What is that??

In general, an anonymous function is a function that is not bound to any identifier; mostly common with nested functions. In JavaScript, they are mostly common with closures (lesson below) and as arguments, or callbacks.

If you have used setTimeout or setInterval, you have used an anonymous function, well sort of.

Declaration

an anonymous function is declared as any variable, using the var keyword, or just declared as a function without any identifier.

var anonymous = function(){
    console.log("Hi from anon");
}
anonymous();

// Closure style. A lot more anonymous
(function(){
    // Do the thing.
    // See this can't be called ever again
})();

/*
   The ending parentheses
   call the function.
   You can add arguments.
 */

Remember that a var will only be accessible in it's appropriate stack frame.

setTimeout using anonymous format

setTimeout(function() {
    console.log("setTimeout anon");
}, 256);

The function part can never be called again. That is pretty much the definition.

Actually, you can call the function again, but only within itself (recursively, in other terms).

console.log(
    (function factorial(n){
        return (n <= 1) ? 1 : factorial(n - 1) * n;
    })(5)
);

Callbacks

A callback calls a function after the current function has finished executing. The function to be called back is passed in as an argument.

// Our declared function to be called back
var callme = function(name){
    console.log("Thanks for calling " + name);
}

// The main function to use
function doathing(arg1, callback){
    arg1 *= 10.5;
    callback(arg1);
}

// Using default
doathing(40, callme);

// Hey we can overwrite it to be anonymous!!
doathing(80, function(arg2){
    console.log("Anon callback version 2: " + arg2);
});

Thanks for tuning in! Below is the closures lesson; you can skip it or learn. Next chapter will be JS Objects! Examples in JS tab for this chapter!!

Function Closures

What?

A closure is a function that is lexically scoped (also known as lexical closures).

Honestly, I did not understand them 100% while in school and never used them since, so take my lesson lightly (and I did do a bit of research for a refresher and to not give misleading information).

Closures allow for accessing function variables (variables that are declared within said function) even when the function is invoked outside of its scope.

In other words, you can access variables of a function even after the function has terminated. Or, the variables have been preserved for later use.

They could also be used as a placeholder for static variables in JS.
```
// Var version
function quickScope(num){
    var destroyed_after = num * 42;
    var save = function(){return destroyed_after;}
    
    return save;
}

var mystery = quickScope(10);
console.log(mystery());

// Non-var version
// Most common
function quickScope_com(num){
    var destroyed_after = num * 42;
    
    return (function(){
        return destroyed_after;
    });
}

var mystery = quickScope_com(10);
console.log("Common: " + mystery());
                            
```
Of course, the closure itself does not have access to variables declared after said closure.

Thanks for tuning in! Next chapter will be JS Objects! Examples in JS tab!!

CH. 04.5 Anonymous Functions and Closures

Anonymous Functions

What is that??

Declaration

Callbacks

Function Closures

What?

[JS Tutorial] CH 04.5 Anonymous Functions and Closures