Uncaught TypeError: Cannot read property of undefined

December 13, 2022

Uncaught TypeError: Cannot read property of undefined

This guide is part of the “Common JavaScript Errors” series. It’s focused entirely on providing quick and easy solutions for JavaScript-related problems.


The Cannot read property '<property>' of undefined error is thrown when you try to access a property of an undefined value. This typically happens when you try to access a property of a variable that hasn't been assigned a value.

A few other common scenarios include:

  • You are trying to access a property of an object that is undefined.
  • You are trying to access an index of an array that is out of bounds.
  • You are trying to call a function that is undefined.
  • You are trying to access a variable that is undefined.

In general, this error occurs when you are trying to access a value that is undefined, either because it was never assigned a value, or because it was explicitly set to undefined.

Uncaught TypeError Cannot read property of undefined

Here's an example of how this error could be thrown:

// Define a variable, but don't give it a value
let user;

// Try to access a property of the variable
console.log(user.name); // Throws 'Cannot read property 'name' of undefined'

To fix this error, you need to make sure that the variable has been assigned a value before you try to access its properties. You can do this by either assigning a value to the variable when you declare it, or by assigning a value to it later in your code.

// Define a variable with a default value
let user = { name: 'John Doe' };

// Access the property of the variable
console.log(user.name); // Outputs: 'John Doe'

Alternatively, you could check if the variable is undefined before you try to access its properties, like this:

// Define a variable, but don't give it a value
let user;

// Check if the variable is defined before accessing its properties
if (typeof user !== 'undefined') {
  console.log(user.name);
} else {
  console.log('user is not defined');
}

Array index out of bounds

This error can also occur when you are trying to access an element of an array using an index that is outside of the bounds of the array. For example:

const colors = ['red', 'green', 'blue'];

console.log(colors[3]); // This will throw an error, because the index 3 is out of bounds of the array

To fix this, you need to make sure that you are not trying to access an element of an array using an index that is out of bounds. You can do this by checking the length of the array before trying to access an element using an index, like this:

const colors = ['red', 'green', 'blue'];

const index = 3;

if (index >= 0 && index < colors.length) {
    // This will print the element at the specified index
    console.log(colors[index]);
} else {
    console.log('The index is out of bounds');
}

Using a fallback value

Another solution is to avoid accessing the property altogether when the variable is undefined, and use a default fallback value instead:

const person = {
    name: 'John Doe'
};

// If the `age` property is not defined on the `person` object, we will use the default value of 30
const age = person.age || 30;

console.log(age); // This will print 30

This technique can be useful when you are dealing with variables that may or may not be defined, and you want to avoid the "cannot read property of undefined" error by providing a default value instead.


Using a replacement

Depending on your application, you can also try to replace the undefined variable with a default value, using the || operator. Here is an example:

let person;

// If the `person` variable is undefined, we will use a default object instead
person = person || {
    name: 'John Doe',
    age: 30,
    job: 'unemployed'
};

console.log(person.name); // This will print 'John Doe'

You can also use the ?? operator:

let person;

// If the `person` variable is undefined, we will use a default object instead
person = person ?? {
    name: 'John Doe',
    age: 30,
    job: 'unemployed'
};

console.log(person.job); // This will print 'unemployed'

The ?? operator returns the right-hand operand if the left-hand operand is null or undefined, rather than any falsy value.

const x = null;
const y = 5;

// Without the ?? operator, this would evaluate to false and x would be assigned the value of 0
const result = x ?? y;

// With the ?? operator, the result variable will be assigned the value of y (5)
// because the left-hand operand (x) is null
console.log(result); // 5