[VL] Immediately Invoked Functions

Immediate Functions

Definition and Purpose
- Immediate functions, also known as IIFEs (Immediately Invoked Function Expressions), are a coding pattern in JavaScript.
- They allow for the execution of a function immediately after its creation.
- This pattern is used to avoid polluting the global namespace by containing variables within the scope of the function itself.
Scope of Variables
- The scope of a variable refers to where that variable is accessible within the program.
- Variables declared within a function are not accessible outside of that function.
- If a variable is declared within a nested function, it remains local to that function.
- This encapsulation prevents global conflicts.
Closure Concept
- A closure is a combination of a function and its lexical environment.
- Closures enable a function to remember the variables from the scope in which it was created, even when it is executed outside that scope.
- The concept of closures will be covered in a subsequent lecture, but it is important to mention as it interrelates with the functionality of immediate functions.
How to Define an Immediate Function
- To create an immediate function, the function is wrapped in parentheses, enabling its immediate invocation.
- Example:
```
  (function() { 
      console.log('Hello');
  })();  
```
- This pattern ensures the function executes immediately.
Function Definition Example
- When defining a function to be invoked immediately:
- Example of a simple function a:
```
  function a() {  
      console.log('Hi');  
  }  
```
- To immediately invoke it, wrap it in parentheses and add parentheses after its definition:
```
  (function a() {  
      console.log('Hi');  
  })();  
```
- This executes the function upon definition, allowing for inline initialization of variables without affecting the global scope.
Advantages and Disadvantages of Immediate Functions
- Advantages:
- Helps to maintain clean global scope by encapsulating variables.
- Allows for setup and initialization tasks without exposing internals.
- Disadvantages:
- Since the function is executed immediately, it cannot be reused later in the code.
- Limits functionality for cases where the same initialization might be needed multiple times.
Nesting Functions
- Functions can be nested within other functions in JavaScript, enabling the creation of private functions.
- Example of an outer function with a nested inner function:
```
function outer() {  
    function inner(param) {  
        return param * 2;  
    }  
    return inner;  
}
```
- Upon calling outer(), it will return the inner function inner, but inner itself cannot be accessed directly from outside of outer, thus maintaining encapsulation.
- Trying to call inner outside of outer will result in a reference error, demonstrating that inner is not defined in the outer scope.
Returning Functions from Functions
- Functions can be returned from other functions, treating functions as first-class citizens (data).
- Example:
```
function a() {  
    console.log('Now in function A');  
    return function b() {  
        console.log('Now in function B');  
    };  
}  
```
- Calling a() will execute its body (logging to the console) and return the function b. To execute b, it must be called:
```
const funcB = a();  
funcB();  
```
Practical Uses
- The use of immediate functions and nested functions helps in situations where modularity is desired, or when configuration menus need to be created without excessive conditional branching.
- Emphasizing the importance of these concepts in building JavaScript applications leads to a deeper understanding of scope, encapsulation, and functional programming.
Future Topics
- The next lecture will discuss closures in greater detail and how they work in conjunction with immediate functions and nesting.
Encouragement for Exploration
- Students are encouraged to play around with these concepts and to consider their practical applications as they continue learning JavaScript.
- The objective is to develop a well-rounded, skilled understanding of programming in JavaScript by utilizing these techniques effectively.