What is the difference between global and local scope in JavaScript?
In JavaScript, scope refers to the accessibility and visibility of variables, functions, and objects in a particular part of the code. The concept of scope is important in understanding how variables and functions are organized and accessed within a program. JavaScript has two main types of scope: global scope and local scope.
Global Scope:
The global scope in JavaScript refers to variables, functions, and objects that are accessible throughout the entire program. When a variable or function is declared outside of any function or block, it becomes part of the global scope. This means that it can be accessed from anywhere within the program, including other functions and blocks. Variables declared in the global scope are also known as global variables.
Here is an example of a global variable:
javascript
var globalVariable = "I am a global variable";
function printGlobalVariable() {
console.log(globalVariable);
}
printGlobalVariable(); // Output: I am a global variable
In the above example, the `globalVariable` is declared outside of any function, making it accessible from within the `printGlobalVariable` function.
Local Scope:
The local scope in JavaScript refers to variables, functions, and objects that are accessible only within a specific function or block. When a variable or function is declared inside a function or block, it becomes part of the local scope. This means that it can only be accessed from within that particular function or block. Variables declared in local scope are also known as local variables.
Here is an example of a local variable:
javascript
function printLocalVariable() {
var localVariable = "I am a local variable";
console.log(localVariable);
}
printLocalVariable(); // Output: I am a local variable
console.log(localVariable); // Throws an error: ReferenceError: localVariable is not defined
In the above example, the `localVariable` is declared inside the `printLocalVariable` function, making it accessible only within that function. Trying to access the `localVariable` outside of the function will result in a ReferenceError.
The key difference between global and local scope is the accessibility of variables, functions, and objects. Global scope allows access from anywhere in the program, while local scope restricts access to the specific function or block where it is declared.
It is important to note that variables declared in local scope can have the same name as variables declared in global scope. In such cases, the local variable takes precedence over the global variable within the scope where it is declared. This is known as variable shadowing.
javascript
var myVariable = "Global variable";
function printVariable() {
var myVariable = "Local variable";
console.log(myVariable);
}
printVariable(); // Output: Local variable
console.log(myVariable); // Output: Global variable
In the above example, the local variable `myVariable` within the `printVariable` function shadows the global variable `myVariable` when accessed within the function.
Understanding the scope in JavaScript is important for writing clean and maintainable code. By properly organizing variables and functions within their respective scopes, we can prevent naming conflicts and improve code readability.
Other recent questions and answers regarding Examination review:
- Why is it generally recommended to limit the use of global variables in JavaScript?
- What is shadowing in JavaScript and how does it affect variable access?
- What happens when a function encounters a return statement?
- How are global variables accessed within functions?