🚀 Difference Between var, let, and const in TypeScript / JavaScript

In TypeScript (and JavaScript), you have three ways to declare variables: var, let, and const. Although they all seem similar, there are important differences in how they behave in terms of scope, hoisting, and mutability.

✅ 1. var – The Traditional Way

📌 Use:

• Used to declare variables globally or locally to an entire function.
• Function-scoped.
• Hoisted to the top of its scope, but not initialized.

🔍 Behavior:

• If declared outside a function → Global scope.
• If declared inside a function → Local to the function.
• Accessible even before declaration due to hoisting (but value is undefined).

🔧 Example:

function testVar() {
  console.log(x); // undefined
  var x = 10;
  console.log(x); // 10
}
testVar();

⚠️ Pitfall:

for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 1000);
}
// Output: 3, 3, 3 — because `var` is function-scoped, not block-scoped.

✅ 2. let – Modern, Block-Scoped

📌 Use:

• Introduced in ES6 (and TypeScript) to overcome issues with var.
• Block-scoped (limited to {}).
• Not hoisted the same way as var.

🔍 Behavior:

• Not accessible before declaration (Temporal Dead Zone).
• Preferred when the variable value may change.
• Safer and more predictable than var.

🔧 Example:

function testLet() {
  let x = 10;
  if (true) {
    let x = 20;
    console.log(x); // 20
  }
  console.log(x); // 10
}
testLet();

✅ Solution to earlier var pitfall:

for (let i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 1000);
}
// Output: 0, 1, 2 — Each iteration has its own block scope.

✅ 3. const – Constant, Block-Scoped

📌 Use:

• Used to declare a constant — a variable that cannot be reassigned.
• Also block-scoped.
• Must be initialized when declared.

🔍 Behavior:

• Cannot be reassigned.
• Can be used for global constants.
• Still mutable for object properties or array contents (but not the variable itself).

🔧 Example:

const PI = 3.14159;
// PI = 3.14; ❌ Error: Cannot assign to 'PI'

const arr = [1, 2, 3];
arr.push(4); // ✅ Allowed: internal mutation
console.log(arr); // [1, 2, 3, 4]

🔄 Summary Table

🧠 Quick Best Practices

• Use const by default.
• Use let only if the variable’s value will change.
• Avoid var unless maintaining legacy code.

💻 5 Programming Assignments on var, let, and const

🧩 Assignment 1: Temperature Converter with let

Write a TypeScript program that converts Celsius to Fahrenheit using the formula:
F = C × 9/5 + 32

✅ Use let for all variables since values may change during calculation.
✅ Input can be hardcoded or prompted.

🧩 Assignment 2: Constant Pi Area Calculator

Create a program to calculate the area of a circle using the formula:
Area = π × r²

✅ Use const for π = 3.14159
✅ Use let for radius and area
✅ Print the result with a clear message.

🧩 Assignment 3: Loop with let Index

Write a loop that prints numbers 1 to 5.
Inside the loop, create a variable that stores the square of the number.

✅ Use let for both the loop index and square variable.
✅ Avoid using var.

🧩 Assignment 4: Object Modification with const

Create a const object for a car:

const car = { brand: "Toyota", year: 2020 };

Modify the year property to 2025 and print the updated object.

✅ Do not reassign the object, just modify it.
✅ Print both before and after the change.

🧩 Assignment 5: var vs let in Loop Scope

Write a program using var inside a for loop, then repeat using let. After the loop ends, try to print the loop variable.

✅ Compare what gets printed for var and let
✅ This helps observe scope differences.