vl - simple closures

Definition of Closures: Closures are functions that have access to the outer function's scope even after the outer function has executed. They may introduce complexities for beginners in JavaScript, but they are integral to the language.
Purpose: Closures help maintain access to variables from an outer function in a nested inner function, allowing it to survive after the parent function's execution.

Scope: The context in which variables are accessible in JavaScript. JavaScript supports different types of scope:
- Global Scope: Variables declared outside any function are global and can be accessed anywhere in the code.
- Function Scope: Variables declared within a function are only visible inside that function.

Unlike C# and Java, JavaScript does not provide block scope (variables declared within curly braces of control statements like loops or conditionals are globally accessible).
Statement Block: A sequence of statements enclosed within curly braces { }. For example, in control structures like if, while, etc., in C# and Java, a variable declared inside such blocks is not accessible outside them,
- Example: In JavaScript, a variable declared inside a loop can still be accessed outside of that loop.

Global Variables: Declared outside any function, accessible from anywhere in the code.
Local Variables: Declared within a function, inaccessible from outside that function.

Variable Declaration:
- Declaring a variable var a = 1; outside any function makes it a global variable.
- Declaring var notVisible = 2; inside a function checkMe limits its visibility only to that function. Thus, trying to access notVisible outside checkMe will result in a reference error.

Variables declared in an outer function are accessible from its inner functions.
Example: If inner is a function declared inside checkMe, it can access variables defined in checkMe (function scope rules apply).

Code Example:
- var global = 1;
- function outer() {
- var outerLocal = 2;
- function inner() {
  - var innerLocal = 3;
  - return innerLocal + outerLocal + global;
- }
- return inner();
The result from invoking outer() will be 6, because it sums innerLocal (3) + outerLocal (2) + global (1) = 6.

Concept of a Closure: Closures allow inner functions to remember the lexical scope in which they were created, thus retaining access to variables in the parent scope.
Example of Closure: If function f encapsulates a local variable b, and it uses an inner function n with its own local variable c, the inner function n can access b due to its scope. Conversely, it cannot access c from the outer function.
- Returning Functions: When returning an inner function, it retains access to the outer function's variables.

Code Structure:
- function f() { var b = "local variable"; function n() { return b; } return n; // Returning function n }
When invoking the function through a closure, even after f has executed, function n can still access variable b.
Result: Calling the returned function will not produce a reference error; instead, it delivers "local variable" because n retains closure over b.

Closures: Functions that maintain access to their parent's scope even when the parent function has executed.
Scope matters greatly in understanding closures, as it determines variable accessibility.
The concept of closures in JavaScript can be both powerful and confusing for newcomers, and practical examples can illuminate their utility and application.