JavaScript Tutorial #22 - Scope

Welcome to Software Interview Prep! Our channel is dedicated to helping software engineers prepare for coding interviews and land their dream jobs. We provide expert tips and insights on everything from data structures and algorithms to system design and behavioral questions. Whether you're just starting out in your coding career or you're a seasoned pro looking to sharpen your skills, our videos will help you ace your next coding interview. Join our community of aspiring engineers and let's conquer the tech interview together!
----------------------------------------------------------------------------------------------------------------------------------------
Scope in JavaScript refers to the context or environment in which variables and functions are declared and can be accessed. It determines the visibility and lifetime of variables, as well as how they are accessed and manipulated within a program. Understanding scope is crucial for writing correct and maintainable JavaScript code.

There are two main types of scope in JavaScript:

1. **Global Scope**:
- Variables declared outside of any function or block have global scope. They are accessible from anywhere in the JavaScript code, including within functions and blocks.

```javascript
const globalVariable = "I am global";

function globalFunction() {
}

globalFunction(); // Outputs: "I am global"
```

- Global variables should be used sparingly to avoid polluting the global scope, which can lead to naming conflicts and unintended interactions with other code.

2. **Local (Function) Scope**:
- Variables declared within a function have local scope, meaning they are accessible only within that function. They are not visible or accessible from outside the function.

```javascript
function localFunction() {
const localVariable = "I am local";
}

localFunction(); // Outputs: "I am local"
```

- Each function creates its own scope, and variables declared within that function are isolated from the outer scope.

JavaScript also has block scope, which was introduced in ECMAScript 6 (ES6) with the `let` and `const` keywords. Variables declared with `let` and `const` have block scope, which means they are accessible only within the block (e.g., within loops or conditional statements) where they are declared.

```javascript
if (true) {
let blockVariable = "I am in a block";
}

```

Scope determines variable visibility, access, and lifetime. Variables declared in an inner scope can shadow (hide) variables of the same name in an outer scope, but the outer variables are not affected by changes made to the shadowed variables. Proper understanding of scope is essential for avoiding bugs related to variable naming conflicts and for writing clean, maintainable code.