let age: number = 21;
let name: string = "Ravi";
let isStudent: boolean = true;

function add(a: number, b: number): number {
  return a + b;
}

add(5, "10");   // ❌ TypeScript catches this at compile time - can't add a number and a string

TypeScript's core value proposition, right here: the mismatched-type call to add() is caught immediately by your editor and the compiler, long before it would have become a confusing runtime bug in plain JavaScript.

interface Student {
  name: string;
  age: number;
  email?: string;   // the ? marks this property as optional
}

function greet(student: Student): string {
  return `Hello, ${student.name}`;
}

greet({ name: "Neha", age: 22 });               // ✅ valid - email is optional
greet({ name: "Raj" });                          // ❌ error - age is required

An interface describes the exact shape an object must have. TypeScript checks every object passed where a Student is expected, catching missing or mistyped fields immediately — exactly the kind of prop-shape bug that plain React/JavaScript can only catch at runtime, if at all.

type Status = "loading" | "success" | "error";

function getMessage(status: Status): string {
  if (status === "loading") return "Please wait...";
  if (status === "error") return "Something went wrong.";
  return "Done!";
}

function printLength(value: string | number) {
  if (typeof value === "string") {
    console.log(value.length);   // TypeScript now KNOWS this is a string here
  } else {
    console.log(value.toFixed(2));  // and knows this branch is a number
  }
}

A union type (string | number) means a value could be either type. Type narrowing — checking with typeof or comparing against specific values — lets TypeScript automatically figure out exactly which type applies inside each branch, unlocking the correct methods for that specific type.

function getFirstItem<T>(items: T[]): T {
  return items[0];
}

const firstNumber = getFirstItem([1, 2, 3]);          // TypeScript infers T is number
const firstName = getFirstItem(["Amit", "Neha"]);   // TypeScript infers T is string

Generics let a function work correctly with any type while still preserving full type safety — getFirstItem works on an array of any type, and TypeScript always knows exactly which type it returned for that specific call, without needing to write a separate version per type.