# temporal dead zone

# 1\. `var` vs `let` vs `const`

### `var`

* Function-scoped.
    
* Can be redeclared and updated.
    
* Hoisted to the top of the scope → initialized with `undefined`.
    

```javascript
console.log(a); // undefined (hoisted)
var a = 10;
```

---

### `let`

* Block-scoped.
    
* Can be **updated**, but **not redeclared** in the same scope.
    
* Hoisted but **not initialized** → stays in the **Temporal Dead Zone (TDZ)** until the declaration line.
    

```javascript
console.log(b); // ❌ ReferenceError (TDZ)
let b = 20;
```

---

### `const`

* Block-scoped.
    
* Must be **declared + initialized at the same time**.
    
* Cannot be updated or redeclared.
    
* Also lives in the TDZ before initialization.
    

```javascript
console.log(c); // ❌ ReferenceError (TDZ)
const c = 30;
```

---

# 2\. 🔥 What is the Temporal Dead Zone (TDZ)?

* The time between **hoisting** (when memory is allocated) and **initialization** (actual value assigned).
    
* For `let` and `const`, variables exist in memory but are in a **“dead zone”** → accessing them gives `ReferenceError`.
    

👉 Why? To prevent using variables before they are safely initialized.

---

# 3\. Deep Example

```javascript
// Global Scope
console.log(a); // undefined
// console.log(b); // ReferenceError (TDZ)
// console.log(c); // ReferenceError (TDZ)

var a = 1;
let b = 2;
const c = 3;

function test() {
    // TDZ for x, y, z starts here
    // console.log(x, y, z); // ReferenceError for y, z

    var x = "var inside";
    let y = "let inside";
    const z = "const inside";

    console.log(x); // "var inside"
    console.log(y); // "let inside"
    console.log(z); // "const inside"
}
test();
```

---

# 4\. Scope & Block Example

```javascript
{
    var v = "I am var";
    let l = "I am let";
    const c = "I am const";
}

console.log(v); // ✅ "I am var"
// console.log(l); // ❌ ReferenceError
// console.log(c); // ❌ ReferenceError
```

👉 `var` escapes out of the block → only function-scoped.  
👉 `let` and `const` stay inside the block → block-scoped.

---

# 5\. 🧠 Why TDZ Exists?

* To **make** `let` and `const` safer than `var`.
    
* If TDZ didn’t exist:
    
    ```javascript
    console.log(x); // would be undefined
    let x = 10;
    ```
    
    This could cause bugs because you might accidentally use an uninitialized variable.
    
* TDZ forces you to **declare before use**.
    

---

# 6\. Tree Diagram (Execution Context Example)

```javascript
// Global LE
{
   a: undefined  (var)
   b: uninitialized (TDZ)
   c: uninitialized (TDZ)
}
```

Before execution:

* `a` is hoisted → `undefined`
    
* `b` and `c` are hoisted too but stay uninitialized (TDZ)
    

When JS reaches:

* `var a = 1;` → initializes
    
* `let b = 2;` → initializes
    
* `const c = 3;` → initializes