Hoisting என்றால் என்ன?

Question

Accepted Answer

**Hoisting** என்பது JavaScript-இன் **declarations**-ஐ அவற்றின் scope-இன் மேலே நகர்த்தும் நடத்தை ஆகும், இது compile phase-இல் நிகழ்கிறது, எந்த code-ஆனாலும் run ஆகுவதற்கு முன்பு. ஆனால் ஒன்று எப்படி hoisted ஆகிறது என்பது declaration type-ஐ பொறுத்து வேறுபடுகிறது.

```js
console.log(a); // undefined  — `var a` is hoisted & initialized to undefined
var a = 1;

foo();          // "works!" — function declarations are fully hoisted
function foo() { console.log("works!"); }

console.log(b); // ❌ ReferenceError — temporal dead zone
let b = 2;
```

## என்ன hoisted ஆகிறது, மற்றும் எப்படி

- **`var`**: declaration hoisted ஆனது மற்றும் `undefined`-ற்கு initialize செய்யப்பட்டது. எனவே early-ல் படிக்கும் போது `undefined` கிடைக்கிறது, error அல்ல.
- **`function` declarations**: முழுவதுமாக hoisted — அவற்றின் definition line-ற்கு முன்பு அவற்றை call செய்ய முடியும்.
- **`let` / `const`**: hoisted ஆனது ஆனால் **initialize செய்யப்படவில்லை**. அவை block-இன் தொடக்கத்திலிருந்து அவற்றின் declaration line வரை *Temporal Dead Zone* (TDZ)-ல் உள்ளன; TDZ-ல் அவற்றை access செய்வது `ReferenceError`-ஐ throw செய்கிறது.
- **Function expressions** (`const f = () => {}`) early-ல் *call செய்ய முடியாது* — `const`/`var` binding மாத்திரம் hoisted ஆகிறது, function அல்ல.

## இது ஏன் முக்கியமாக உள்ளது

Hoisting "ஏன் இது `undefined`?" மற்றும் "ஏன் இந்த function-ஐ அதன் definition-க்கு முன்பு call செய்வது வேலை செய்கிறது?" என்பதை விளக்குகிறது. `let`/`const`-க்கான TDZ உண்மையில் ஒரு *feature* — இது silent `undefined` bugs-களை loud errors-ஆக மாற்றுகிறது, declare செய்ய use-ற்கு முன்பு ஊக்குவிக்கிறது.