TypeScript theorytheory 0/50 · 0%
Types · hard

46. Structural typing pitfalls & excess property checks

When structural typing surprises you, and when it protects you.

Because TypeScript is structurally typed, an object with *extra* properties can usually be assigned to a variable of a narrower type through a reference — but object literals assigned directly are checked more strictly ('excess property checking').

ts
interface Config { chainId: number; }

function useConfig(c: Config) {}

const obj = { chainId: 1, extra: true };
useConfig(obj); // OK: obj is assigned via a variable, structurally compatible

useConfig({ chainId: 1, extra: true });
// error: object literal may only specify known properties, 'extra' does not exist in type Config

This special-case check exists because object literals are usually typos waiting to happen — if you meant to pass `extra`, you likely misspelled a `Config` field. To intentionally allow extras, add an index signature to `Config`, or assign the literal to a variable first (as in the `obj` example) to bypass the stricter literal check.

Check your understanding

  1. 1. Why does passing `{ chainId: 1, extra: true }` directly to `useConfig` fail, but passing it via a variable succeeds?

  2. 2. What is the underlying reason TypeScript allows the variable-based assignment?

  3. 3. How can you intentionally allow arbitrary extra properties on Config?