JavaScript Variables & Constants Kya Hote Hain?

JavaScript Variables Kya Hote Hain?

Jab humein kisi bhi value ko store karna hota hai, toh hum variables ka use karte hain. JavaScript me 3 tareeke ke variables declare kiye ja sakte hain:

• var: Purana tarika, jo ab avoid karna chahiye.
• let: Naya aur behtar tarika, jo flexible aur safe hai.
• const: Jab value change nahi karni ho tab iska use karte hain.

1. var – Old JavaScript Variable (Avoid Karna Chahiye)

Pehle JavaScript me sirf var hi hota tha, lekin isme scoping aur hoisting issues hote hain, jo unexpected bugs create kar sakte hain.

• Function Scope: Sirf function ke andar work karta hai, block { } ke andar nahi.
• Hoisting: Memory me undefined ke sath reserve ho jata hai.
• Redeclaration Allowed: Ek hi naam ka variable phirse declare kar sakte hain.
• No Block Scope: Block { } ke andar declare hone ke baad bhi globally accessible hota hai.

Example 1: `var` ka Block Scope Issue

function testVar() {
  var x = 10;
  if (true) {
    var x = 20; // Yeh pura function ke andar x ki value change kar dega
    console.log("Inside if block:", x); // Output: 20
  }
  console.log("Outside if block:", x); // Output: 20
}
testVar();

Issue: `var` ka scope function level hota hai, block { } level nahi, is wajah se `x` ki value pura function me change ho gayi.

Example 2: `var` Hoisting Problem

console.log(a); // Output: undefined
var a = 5;
console.log(a); // Output: 5

Explanation: JavaScript me `var` hoist hota hai, yaani variable ko code execute hone se pehle memory me allocate kiya jata hai, lekin bina kisi value ke `undefined` assign hota hai.

2. let – Modern JavaScript Variable (Best Practice)

JavaScript ke ES6 (ECMAScript 2015) version me `let` introduce kiya gaya, jo `var` ki problems ko solve karta hai.

• Block Scope: Sirf { } block ke andar accessible hota hai.
• Hoisting but Not Initialized: Access karne se pehle initialize karna zaroori hai (Temporal Dead Zone).
• Redeclaration Not Allowed: Ek hi scope me same naam ka variable dubara declare nahi kar sakte.

Example 1: `let` ka Block Scope

function testLet() {
  let y = 10;
  if (true) {
    let y = 20; // Yeh sirf is block ke andar accessible hai
    console.log("Inside if block:", y); // Output: 20
  }
  console.log("Outside if block:", y); // Output: 10
}
testLet();

Advantage: `let` ka scope block ke andar hi limited hota hai, jo ek safe approach hai.

Example 2: `let` Hoisting

console.log(b); // ReferenceError: Cannot access 'b' before initialization
let b = 5;
console.log(b);

Explanation: `let` bhi hoist hota hai, lekin bina initialization ke access karna allowed nahi hai. Is concept ko "Temporal Dead Zone" (TDZ) kehte hain, is wajah se error aata hai.

3. const – Fixed Value Variable (Constant)

Jab hume ek fixed value store karni ho jo kabhi change na ho, tab `const` ka use karte hain.

• Block Scope: Sirf { } block ke andar accessible hota hai.
• Value Change Not Allowed: Ek baar assign hone ke baad `const` ki value re-assign nahi ho sakti.
• Declaration and Initialization Together: Declare karte waqt hi value assign karna zaroori hai.

Example 1: Basic `const` Use

const PI = 3.1416;
console.log(PI); // Output: 3.1416
PI = 3.14; // TypeError: Assignment to constant variable.

Advantage: Jab ek baar value fix ho, toh `const` ka use karna best practice hai.

Example 2: `const` with Objects and Arrays

`const` ka use objects aur arrays me bhi hota hai, lekin yeh sirf variable ke reference ko constant banata hai, uske andar ki values ko nahi. Iska matlab hai ki object ki properties ya array ke elements change ho sakte hain, par pura object ya array reassign nahi ho sakta.

// Object Example
const person = { name: "Rohan", age: 25 };
person.age = 26; // Allowed!
console.log(person.age) // 26

// person = { name: "Amit", age: 30 }; // TypeError

// Array Example
const numbers = [1, 2, 3];
numbers.push(4); // Allowed!
console.log(numbers); // [1, 2, 3, 4]

// numbers = [5, 6, 7]; // TypeError

Difference Between `var`, `let`, and `const`

Best Practices – Kab Kya Use Karein?

• Avoid var: Modern JavaScript me `var` ka use avoid karein, kyunki isme scope aur hoisting problems hoti hain.
• Prefer const: By default, hamesha `const` ka use karein. Isse code predictable rehta hai aur accidental changes se bacha ja sakta hai.
• Use let only when needed: `let` ka use sirf tabhi karein jab aapko pata ho ki variable ki value baad me change karni padegi.