Select Page

As developers, we often encounter scenarios where we need to access properties deep within an object structure. If any intermediate property is null or undefined, attempting to access further properties will throw an error. This is where Optional Chaining comes in handy. In this post, we’ll explore what Optional Chaining is, how it works, and how you can use it to write cleaner, safer TypeScript code.

What is Optional Chaining?

Optional Chaining is a feature in TypeScript (and JavaScript) that allows you to safely access nested object properties. It uses the ?. syntax to check if the value before the ?. is null or undefined, and if so, it returns undefined instead of throwing an error. This makes your code more robust and less vulnerable to runtime errors.

Basic Syntax

The basic syntax of Optional Chaining is straightforward:

const value = obj?.property;

If obj is null or undefined, value will be undefined. Otherwise, value will be the value of


Let’s consider an example where we have a user object with nested properties:

const user = { name: “Alice”, address: { street: “123 Wonderland”, city: “Wonderland” } };

const street = user?.address?.street;

console.log(street); // Output: “123 Wonderland”

Here, we use ?. to safely access address.street. If user or address is null or undefined, street will be undefined instead of causing an error.

Handling null or undefined

Optional Chaining is particularly useful when dealing with potential null or undefined values. Let’s see an example where a property is null:

const user = { name: “Alice”, address: null };

const city = user?.address?.city;

console.log(city); // Output: undefined

In this case, address is null, so trying to access city directly would throw an error. With Optional Chaining, user?.address?.city safely returns undefined.

Using Optional Chaining with Arrays and Functions

Optional Chaining can also be used with arrays and functions. Let’s look at examples for each.


You can use Optional Chaining to safely access elements within an array:

const users = [ { name: “Alice”, age: 30 }, { name: “Bob” } ];

const secondUserAge = users[1]?.age;

console.log(secondUserAge); // Output: undefined

Here, the second user object doesn’t have an age property. Optional Chaining ensures that users[1]?.age returns undefined instead of causing an error.


Optional Chaining is also useful when calling functions that might not exist:

const user = { name: “Alice”, greet: () => “Hello!” };

const greeting = user.greet?.();

console.log(greeting); // Output: “Hello!”

In this example, we safely call the greet function if it exists. If greet were undefined, user.greet?.() would return undefined without throwing an error.

Combining with Nullish Coalescing

You can combine Optional Chaining with the nullish coalescing operator (??) to provide default values when a property is undefined:

const user = { name: “Alice”, address: null };

const city = user?.address?.city ?? “Default City”;

console.log(city); // Output: “Default City”

In this example, if user?.address?.city is undefined, the nullish coalescing operator provides a default value, “Default City”.


Optional Chaining is a powerful feature in TypeScript that simplifies the process of accessing nested properties safely. It helps you avoid runtime errors and makes your code more readable and maintainable. By using ?., you can ensure that your code handles null and undefined values gracefully, without the need for extensive null checks.

Start using Optional Chaining in your TypeScript projects today and experience the benefits of cleaner and safer code!