TypeScript Academy · Lesson

instanceof and in Narrowing

Narrow class instances and object shapes.

instanceof and in Narrowing is a free TypeScript Academy lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the TypeScript Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Welcome

`instanceof` narrows class instances and `in` narrows object types based on property presence. Both are essential for working with complex unions.

instanceof Narrowing

Use `instanceof` to check if a value is an instance of a class. TypeScript narrows the type to that class.

function handle(err: Error | string) {
  if (err instanceof Error) {
    console.log(err.message); // err: Error
  } else {
    console.log(err); // err: string
  }
}

instanceof with Custom Classes

instanceof works with your own classes too.

class Dog { bark() { return 'Woof'; } }
class Cat { meow() { return 'Meow'; } }
function speak(pet: Dog | Cat) {
  if (pet instanceof Dog) pet.bark();
  else pet.meow();
}

instanceof Does Not Work with Interfaces

Interfaces are erased at runtime. You cannot use instanceof with an interface — only with classes.

The in Operator

Use `in` to check if a property exists on an object. TypeScript narrows the union to members that have that property.

type Fish = { swim(): void };
type Bird = { fly(): void };
function move(animal: Fish | Bird) {
  if ('swim' in animal) animal.swim();
  else animal.fly();
}

in Narrowing with Optional Properties

`in` also narrows for optional properties — it narrows to union members where the property CAN exist.

type A = { x?: number };
type B = { y: number };
function process(v: A | B) {
  if ('x' in v) {
    // v: A (has optional x)
  }
}

Combining instanceof and in

You can combine both narrowing techniques for complex type discrimination.

function describe(v: Error | { message: string }) {
  if (v instanceof Error) console.log('Error:', v.stack);
  else if ('message' in v) console.log('Object:', v.message);
}

in for Discriminated Unions

When union members don't have a discriminant, `in` checks can serve the same narrowing purpose.

type Square = { side: number };
type Circle = { radius: number };
function area(s: Square | Circle): number {
  return 'side' in s ? s.side ** 2 : Math.PI * s.radius ** 2;
}

instanceof in catch Blocks

Use instanceof in catch blocks to distinguish error types.

try {
  await fetchData();
} catch (err) {
  if (err instanceof NetworkError) { /* retry */ }
  else if (err instanceof AuthError) { /* redirect */ }
  else throw err;
}

Object.prototype check vs in

Both `key in obj` and `Object.prototype.hasOwnProperty.call(obj, key)` check property existence, but `in` also matches inherited properties.

Narrowing Priority

When multiple narrowing checks apply, TypeScript intersects the narrowed types, giving the most specific type possible.

Quick Check

Why can't you use `instanceof` to narrow an interface type in TypeScript?

Recap

`instanceof` narrows class instances at runtime. `in` narrows object unions based on property existence. Use both when working with class hierarchies and structural object unions.

Frequently asked questions

Is the “instanceof and in Narrowing” lesson free?

Yes — the full text of “instanceof and in Narrowing” is free to read here on the web, and the TypeScript Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the TypeScript Academy course, upgrade to CoddyKit PRO.

What will I learn in “instanceof and in Narrowing”?

Narrow class instances and object shapes. You practise TypeScript Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start TypeScript Academy?

No prior experience is required. TypeScript Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “instanceof and in Narrowing” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this TypeScript Academy lesson?

Yes. Every TypeScript Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to TypeScript Academy