What is structural typing in TypeScript?

Question

Accepted Answer

TypeScript uses **structural typing** ("duck typing"): two types are compatible if they have the **same shape**, regardless of their name or where they were declared. This contrasts with *nominal* typing (Java, C#) where compatibility depends on the declared type name.

```ts
interface Point { x: number; y: number; }

function print(p: Point) { console.log(p.x, p.y); }

// No `: Point` annotation anywhere, but the shape matches:
const obj = { x: 1, y: 2, z: 3 };
print(obj); // ✅ works — obj has x and y (extra z is fine)
```

`obj` was never declared as a `Point`, yet it's accepted because it *structurally* satisfies the shape. Extra properties are allowed when passing an existing variable.

## The excess-property check exception

```ts
print({ x: 1, y: 2, z: 3 }); // ❌ Error: 'z' does not exist in type 'Point'
```

Object **literals** passed directly get a stricter "excess property check" to catch typos — but assign it to a variable first and it passes. This is a deliberate balance between flexibility and catching mistakes.

## Why it matters

Structural typing makes TypeScript flexible and ergonomic — you can satisfy an interface without explicitly implementing it, which suits JavaScript's object-literal style.

The trade-off: types that happen to share a shape are interchangeable even if conceptually unrelated (a reason people use *branded types* when they need nominal-like distinctness).