1️⃣ What Are Variables in TypeScript?
A variable is a container for storing values. In TypeScript, variables must have a specific data type.
✔ Example of a variable in TypeScript:
let message: string = "Hello, TypeScript!";
console.log(message);
✅ message is a variable that stores a string value.
2️⃣ Declaring Variables in TypeScript
TypeScript provides three ways to declare variables:
✔ let – Block-scoped variable (Preferred)
✔ const – Block-scoped, cannot be reassigned
✔ var – Function-scoped (Not recommended)
| Keyword | Scope | Reassignment Allowed? | Hoisting |
|---|---|---|---|
| let | Block | ✅ Yes | No |
| const | Block | ❌ No | No |
| var | Function | ✅ Yes (Avoid using) | Yes |
Let’s look at examples of each.
3️⃣ Using let in TypeScript
let is the most commonly used keyword for declaring variables.
✔ Example:
let userName: string = "Alice";
console.log(userName);
✅ userName is a string variable that can be changed later.
✔ Updating the variable:
let score: number = 100;
score = 150; // ✅ Allowed
console.log(score); // Output: 150
🔹 let is block-scoped
let variables are only accessible inside the block where they are declared.
if (true) {
let city: string = "New York";
console.log(city); // ✅ Works
}
console.log(city); // ❌ Error: city is not defined
✅ Best Practice: Always prefer let over var.
4️⃣ Using const in TypeScript
const is used when you don’t want to change a variable’s value.
✔ Example:
const PI: number = 3.14;
console.log(PI);
🚫 Reassigning a const variable gives an error:
const country: string = "India";
country = "USA"; // ❌ Error: Cannot assign to 'country' because it is a constant.
🔹 const is block-scoped
if (true) {
const language: string = "TypeScript";
console.log(language); // ✅ Works
}
console.log(language); // ❌ Error: language is not defined
✅ Best Practice: Use const for values that never change (e.g., API URLs, configuration values).
5️⃣ Using var in TypeScript (Not Recommended)
var was used before ES6, but it has many issues, so avoid using it.
✔ Example of var:
var age: number = 25;
console.log(age);
🚫 Why var is bad?
✔ It ignores block scope, causing unpredictable errors.
✔ It gets hoisted, meaning it can be used before declaration.
console.log(car); // Output: undefined (Hoisting issue)
var car: string = "BMW";
✅ Best Practice: Never use var, always prefer let or const.
6️⃣ Variable Type Annotations in TypeScript
TypeScript allows you to specify data types for variables. This is called type annotation.
| Data Type | Example |
|---|---|
| string | let name: string = “John”; |
| number | let age: number = 25; |
| boolean | let isStudent: boolean = true; |
| any | let value: any = 10; |
| array | let numbers: number[] = [1, 2, 3]; |
✔ Examples of different data types:
let username: string = "Alice"; // String
let score: number = 95.5; // Number
let isPassed: boolean = true; // Boolean
let data: any = "Hello"; // Any type (Avoid using)
let numbers: number[] = [1, 2, 3]; // Array
🚫 Avoid using any type because it removes type safety.
7️⃣ TypeScript Variables with Union Types
Union types allow a variable to store multiple types.
✔ Example:
let id: number | string;
id = 101; // ✅ Valid
id = "TS101"; // ✅ Valid
✅ Best Practice: Use union types when a variable needs to hold different types.
8️⃣ TypeScript Variables with Default Values
Variables can have default values in TypeScript.
✔ Example:
let color: string = "blue"; // Default value
console.log(color); // Output: blue
✔ Example with functions:
function greet(name: string = "User") {
console.log(`Hello, ${name}!`);
}
greet(); // Output: Hello, User!
greet("John"); // Output: Hello, John!
✅ Best Practice: Use default values to handle cases when no value is provided.
🔟 Best Practices for TypeScript Variables
✔ Use let for variables that can change.
✔ Use const for values that never change.
✔ Avoid var because it has scope issues.
✔ Always define the correct data type.
✔ Use union types for flexible variables.