JavaScript Introduction javascript Variables Javascript Data Types Javascript Operators Javascript if Statement Javascript Switch Statement Javascript Loops Javascript Break and Continue Javascript Functions Javascript Arrays Javascript Objects Javascript Events Javascript Scope Javascript Hoisting

Javascript Scope

Javascript

Scope in JavaScript refers to the accessibility or visibility of variables, functions, and objects in different parts of your code during runtime. Understanding scope is crucial for writing efficient and bug-free JavaScript code. Here are some key concepts related to scope:

Global Scope:
Variables declared outside of any function or block have global scope. They can be accessed from any part of the code, including inside functions.
```
javascript
let globalVar = 10;

function myFunction() {
    console.log(globalVar); // Output: 10
}
```

Local Scope:

Variables declared within a function have local scope. They are accessible only within that function and are not visible outside of it.

javascript
function myFunction() {
    let localVar = 20;
    console.log(localVar); // Output: 20
}
console.log(localVar); // Error: localVar is not defined

Block Scope (Introduced in ECMAScript 6):
Variables declared using let and const keywords have block scope. They are accessible only within the block in which they are defined (typically denoted by curly braces {}).
```
javascript
if (true) {
    let blockVar = 30;
    console.log(blockVar); // Output: 30
}
console.log(blockVar); // Error: blockVar is not defined
```
Function Scope:
JavaScript has function scope, meaning variables declared inside a function are visible only within that function. This differs from block scope, where variables are visible only within the block they are declared in.
```
javascript
function myFunction() {
    let functionVar = 40;
    console.log(functionVar); // Output: 40
}
console.log(functionVar); // Error: functionVar is not defined
```
Lexical Scope:
Lexical scope refers to the visibility of variables based on their physical location within the code. In JavaScript, scope is determined at the time of function definition, not at the time of function invocation. This means that functions declared within other functions have access to variables declared in the outer (parent) function's scope.
```
javascript
function outerFunction() {
    let outerVar = 50;

    function innerFunction() {
        console.log(outerVar); // Accessible due to lexical scope
    }

    innerFunction();
}

outerFunction(); // Output: 50
```
Scope Chain:
JavaScript uses a scope chain to resolve variable names. When a variable is referenced, JavaScript first looks for it in the current scope. If it's not found, it moves up the scope chain until it finds the variable or reaches the global scope. This process is called variable resolution.

Understanding scope in JavaScript helps you avoid naming conflicts, manage variable lifetimes efficiently, and write more maintainable code. It's essential to be mindful of scope when writing functions and blocks of code to ensure that variables are accessible where they are needed and inaccessible where they are not.

Thanks for learning