Lexical scoping and closure concepts
Lexical scoping and closures are both fundamental function programming concepts in JavaScript programming that help JavaScript programmers to access declared program variables and manipulate tasks related to existing functions.
So, let’s get to know more about lexical scoping and closure concepts in JavaScript programming.
Lexical Scoping JavaScript Function Concept.
Lexical program scoping refers to the declared variable names in a JavaScript program. It means that the usage scope of any variable of the declared program in the current program so that those variables can be used as reference lexical concepts around the program where these variables are defined from the variable declaration location in the program source code.
In simple language, function lexical scoping means that the scope or usage of the variable of that function in a JavaScript program is limited. Where the location condition of that variable in the function is defined while defining the function.
How lexical scoping works in JavaScript functions.
Variables in JavaScript functions can be accessed or used as references within the block (scope) where they are declared in those functions.
Internal functions declared in the program with lexical scope have access or use of variables within its scope as well as the scopes of all variable reference functions around it. Where it can also have program global function scope where they are defined globally as functions.
Example of lexical function.
function externalFunction() {
let externalVariable = “This is the example of external function”;
function internalFunction() {
console.log(externalVariable); // here it access externalVariable because of lexical scope variable refrence
}
internalFunction();
}
externalFunction(); // Result – This is the example of external function
Explanation of Lexical Function Scope Function
In the above program, internalFunction() accesses externalVariable reference using lexical scoping. Whereas, here internalFunction() is defined or declared inside externalFunction(). Even then it accesses and uses the variable value as reference from the lexical reference scope externalVariable of its enclosing function.
Important points of lexical scoping in function.
- Function Scope Hierarchy – Internal functions in a function program can access and use the variables of external function in any program. But always remember, external functions cannot access the variables reference of internal functions.
- Reference function scope – Remember, program variables declared inside a function can only access and use the reference variables inside that program function or its internal functions.
Closure Concept in JavaScript.
In JavaScript function programming, closure is such a declared program function. Which can access and use the variables of the surrounding function due to its lexical scope reference environment even after the completion of the execution process of the external function in the current program.
In simple language, closure function concept provides permission to a function to remember its lexical scope and access and use the declared variable element. The same closure function even when that function is executed externally in its original scope.
How do closures work in JavaScript functions.
In JavaScript function program when a function is declared or defined inside another function then the internal function closes the variables of the external function. Which means even after the execution of external function is completed, the declared variables of internal function can be accessed and used.
Example of closure function in JavaScript.
function externalFunction() {
let value = 0;
function internalFunction() {
value++;
console.log(value);
}
return internalFunction;
}
const grow = externalFunction(); // here const grow now become a closure scope
Explanation of closure function.
internalFunction() is returned by externalFunction() function, and is assigned to the function variable grow. While, here, even though the execution of externalFunction() has terminated, internalFunction() continues to access the value variable, which is associated with the lexical function reference scope of this program. Every time grow() is called, it stores the value of value, and modifies it on each execution.
Key features of Closures.
- Preserving function variables – In a function program, closures secure and manage the variables of its defined functions as soon as it completes the execution process of the external function.
- Function private data – In a function program, closure features are often used to create private function data, which is accessed or modified only by internal functions in the program. This JavaScript feature is used in data encapsulation in JavaScript function programming.
Example of Closures for JavaScript data encapsulation.
function createvalue() {
let value = 0;
return {
increase: function() {
value++;
console.log(value);
},
decrease: function() {
value–;
console.log(value);
},
inputvalue: function() {
return value;
}
};
}
const value = createvalue();
Explanation of Closures for JavaScript data encapsulation.
Here the createvalue() function in a closure returns an object value which has many methods that have access to the value variable in the program. Here the value variable is of a private nature for the createvalue() function. But here through the closure class features, methods (increase, and decrease, and inputvalue) can still interact or communicate with this data at any time.
Lexical Scoping and Closures Together in JavaScript.
Lexical Scoping and Closures Concept Features are closely connected in JavaScript function programming.
Lexical Scoping in JavaScript programming defines where the declared variables can be accessed or used from in the current program. Based on the active location of the declared program variable.
Whereas in function programs, closures allow the function to continue to access the program variable value from its lexical scope even after the execution of the function that created that function scope has terminated.
Lexical Scoping and Closures Lexical Scoping in a Nutshell.
Lexical Scoping in function programming allows you to keep track of where the function was created in the current program source code. Based on the scope of the function variables, reference scope of the function variables is defined.
Closures using lexical function scoping allow an internal program function to hold references to external function variables and access or use them even after the external function terminates in the current program.
Practical Uses of Closures in JavaScript Programming.
Function Data Privacy.
Closures in JavaScript functions are mostly used to create private functions that cannot be accessed externally in the current program but can be manipulated through the return method in the function.
Function event handlers.
Closures are important for event handlers in JavaScript programs because they allow event handler functions in the current program to access and manipulate declared program variables that are defined while creating the handler in the program was.
Lexical Scoping and Closure Conclusion.
- Function Lexical Scoping – Function lexical scope is used to define the scope of variables in the current program based on their definition location in the JavaScript program source code.
- Function Closures – Closures are functions in JavaScript programs that “remember” variables from the lexical scope reference of the variable even after the execution of the outer function terminates. This method helps in data encapsulation, private variables declaration, security control and management in programming.
