Basic types and interfaces

let title: string = "HTML Fundamentals";
let price: number = 29.99;
let isFree: boolean = false;

interface Course {
  title: string;
  price: number;
  level: "beginner" | "intermediate" | "advanced";
}

const course: Course = { title: "SQL Databases", price: 59.99, level: "intermediate" };

An interface describes the shape an object must have. TypeScript checks it at compile time — pass an object missing price, and your editor flags it before you ever run the code.

TypeScript's type system is structural, not nominal -- it checks whether an object has the right shape, not whether it was explicitly declared as that interface. Two differently-named interfaces with identical fields are interchangeable:

interface Point { x: number; y: number; }
interface Coordinate { x: number; y: number; }

function distance(p: Point): number {
  return Math.sqrt(p.x ** 2 + p.y ** 2);
}

const c: Coordinate = { x: 3, y: 4 };
distance(c); // fine -- c has the right shape, even though it's typed as Coordinate

type aliases are a close alternative to interface for object shapes:

type CourseType = {
  title: string;
  price: number;
};

For plain object shapes, the two are nearly interchangeable. The practical difference: interface can be re-opened later and extended with more fields via a second declaration of the same name (useful for augmenting types from a library), while type cannot -- but type can express things interfaces can't, like unions ("a" | "b") and mapped types. A common convention is interface for object shapes you expect to extend, and type for everything else.

Arrays and tuples round out the basics:

let tags: string[] = ["css", "layout"];
let pair: [string, number] = ["price", 29.99]; // tuple -- fixed length, fixed types per position