TypeScript Academy · Lesson

instanceof and in Narrowing

Narrow class instances and object shapes.

Lesson 2 of 413 steps

instanceof and in Narrowing is a free TypeScript Academy lesson on CoddyKit. This is 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, and your progress syncs across the web and the CoddyKit app. The TypeScript Academy course includes 4 lessons in total.

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?

Answer it in the interactive lesson

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.

Free to start

Learn TypeScript with an AI tutor — free

Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.

Courses: 101
Lessons: 352

Start learning free View the full course

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. 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. The TypeScript Academy course includes 4 lessons in total.

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, so you can start here or from the beginning and move at your own pace. This is lesson 2 of 4.

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