Structural Typing

The plain-language idea

TypeScript's types exist only at compile time — they're checked, then completely erased before your code runs as plain JavaScript. Nothing about a type or interface survives into the actual .js output.

TypeScript decides whether two types are compatible using structural typing: it compares their shape — what properties and methods exist — not their declared name or where they came from. Two types with an identical shape are interchangeable, even if they were never declared as related.

See it in a real thing: two unrelated interfaces, freely interchangeable

interface Point2D {
  x: number;
  y: number;
}

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

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

const c: Coordinate = { x: 3, y: 4 };
distanceFromOrigin(c); // ✅ fine — same shape, no relationship declared

Point2D and Coordinate share nothing but a name difference and an identical shape — and that's enough. TypeScript never asks "was this declared as a Coordinate?" — only "does it have an x: number and a y: number?"

Two interfaces, different names, identical shape: { x: number, y: number }.

BackNext

What people usually miss

Watch out

• Excess property checking only applies to fresh object literals. distanceFromOrigin({ x: 1, y: 2, z: 3 }) is rejected for the extra z — but assigning that same object through a variable first (const p = { x: 1, y: 2, z: 3 }; distanceFromOrigin(p);) is allowed. This trips people up constantly; it's a deliberate extra check specifically for object literals, not a hole in structural typing.
• A type with more properties than required still satisfies a smaller shape, outside the fresh-literal case above. Structural typing only asks "does it have at least what's required," not "does it have exactly this."
• Types don't exist at runtime. You can't write if (x instanceof SomeInterface) — interfaces are erased entirely by compile time. Runtime validation of untrusted data (like an API response) needs a separate tool (e.g. Zod) that actually checks shape while the code is running.
• This isn't a new idea — it's JavaScript's own duck typing, one phase earlier. At runtime, JS never asks what "class" an object claims to be, only whether it has the method you're about to call. Structural typing is that same instinct, enforced before the code ever runs instead of while it does.

Why this matters in interviews

"Is TypeScript nominally or structurally typed?" tests whether you understand how TypeScript actually decides compatibility — and the honest, deeper answer connects it straight back to something you already know: JavaScript itself never cared about declared types either, just shape.