Cannot set property 'settings' of undefined
  • 30-May-2023
Lightrun Team
Author Lightrun Team
Cannot set property 'settings' of undefined

Cannot set property ‘settings’ of undefined

Lightrun Team
Lightrun Team

Explanation of the problem

I am currently using the jquery-lazyload version 1.9.7 in conjunction with ReactJS, and it is functioning properly. However, when attempting to use lazyload version 2.0.0-beta.2 with ReactJS, I encountered the following errors:

Uncaught (in promise) TypeError: Cannot set property 'settings' of undefined
    at LazyLoad (lazyload.js:78)

In my React component, I am invoking the lazyload function as follows:

componentDidMount() {
  const images = this.node.querySelectorAll('.lazyload')
  lazyload(images, {
    threshold: 200,

Troubleshooting with the Lightrun Developer Observability Platform

Getting a sense of what’s actually happening inside a live application is a frustrating experience, one that relies mostly on querying and observing whatever logs were written during development.
Lightrun is a Developer Observability Platform, allowing developers to add telemetry to live applications in real-time, on-demand, and right from the IDE.

  • Instantly add logs to, set metrics in, and take snapshots of live applications
  • Insights delivered straight to your IDE or CLI
  • Works where you do: dev, QA, staging, CI/CD, and production

Start for free today

Problem solution for Cannot set property ‘settings’ of undefined

The top answers to the question provide a general, aggregated solution for the issue:

  1. One recommended solution is to avoid using lazyload() and instead use new lazyload(). By instantiating the lazyload object using the new keyword, you can ensure that it is properly initialized and avoid the error.
  2. Another user encountered a similar problem and discovered that the issue was due to incorrect usage of the Lazyload function. Initially, they were calling it as lazyload(), but the correct approach was to instantiate a new object using new lazyload(). By following this corrected syntax, the error was resolved.

Overall, the key takeaway is to instantiate the lazyload object correctly by using new lazyload() instead of calling it directly with lazyload(). This ensures proper initialization and resolves the encountered error.


Other popular problems with lazyload

Problem: Incompatible Version of Lazyload Library

One common problem encountered with lazyload implementations is the use of an incompatible version of the lazyload library. This can lead to unexpected errors or inconsistencies in the lazy loading functionality. It often occurs when attempting to upgrade from an older version to a newer one, or when using different versions across different components or dependencies.


To address this issue, it is important to ensure that all components and dependencies are using the same compatible version of the lazyload library. Check the documentation or release notes of the library to verify compatibility with the version of ReactJS or other frameworks being used. Update the lazyload library to a compatible version, and make sure to update any related code or configurations accordingly.

Problem: Improper Initialization of Lazyload Object

Another common issue arises from improper initialization of the lazyload object. This occurs when calling the lazyload function directly instead of instantiating the object with the new keyword. Improper initialization can lead to undefined properties or unexpected errors when attempting to use lazy loading functionality within React components.



To resolve this issue, ensure that the lazyload object is properly initialized by using the new keyword when instantiating it. This ensures that all necessary properties and methods are correctly set up for the lazy loading functionality to work as expected within React components.

Problem: Missing or Incorrect Configuration

A common problem when implementing lazyload is the presence of missing or incorrect configuration. This can lead to issues such as images not loading or incorrect behavior of lazy loading features. It often occurs when the configuration options are not properly defined or when the threshold values are not set appropriately.


To overcome this issue, ensure that the lazyload configuration is properly defined and the threshold values are set appropriately. Review the lazyload library documentation to understand the available configuration options and their default values. Adjust the configuration options based on the desired behavior and requirements of your application.

A brief introduction to lazyload

Lazyload is a JavaScript library commonly used in web development to implement lazy loading of images, videos, and other media assets. The purpose of lazy loading is to optimize the performance of a web page by deferring the loading of non-visible or off-screen content until it is actually needed. This technique can significantly improve the initial page load time and reduce bandwidth consumption.

Lazyload works by replacing the src attribute of the media elements with a placeholder, typically a small-sized or blurred image. As the user scrolls or interacts with the page, lazyload dynamically replaces the placeholder with the actual content when it becomes visible within the viewport. This process is typically triggered by the scroll event or other user interactions. By loading the content on-demand, lazyload minimizes the initial payload of the page, resulting in faster rendering and a more responsive user experience. Lazyload libraries often provide additional features such as custom threshold settings, lazy loading of iframes or background images, and callback functions for handling events during the loading process.

Overall, lazyload is a powerful tool for optimizing web page performance by deferring the loading of non-critical content. By selectively loading media assets only when they are needed, lazyload reduces the initial page load time and improves the overall user experience.


Most popular use cases for Lazyload

  1. Lazy Loading Images: Lazyload is commonly used to implement lazy loading of images on web pages. By replacing the src attribute of images with a placeholder or a small-sized thumbnail, lazyload defers the loading of the actual image until it becomes visible within the viewport. This technique improves the initial page load time by reducing the number of network requests and the overall payload size. Here’s an example code block showcasing the usage of lazyload for image lazy loading in JavaScript:
// Select all the images with the 'lazyload' class
const images = document.querySelectorAll('.lazyload');

// Initialize lazyload and specify configuration options
lazyload(images, {
  threshold: 200, // Adjust the threshold value based on your requirements
  1. Lazy Loading Videos: Lazyload can also be utilized to implement lazy loading of videos. Similar to image lazy loading, lazyload replaces the src attribute of video elements with a placeholder or a thumbnail, and then loads the actual video content when it becomes visible within the viewport. By employing lazy loading for videos, web pages can avoid unnecessary loading of heavy video files upfront, resulting in faster initial load times. Lazy loading videos can be achieved by applying similar techniques as image lazy loading, with the appropriate modifications for handling video elements.
  2. Lazy Loading Content on Scrolling or User Interaction: Apart from images and videos, lazyload can be used to defer the loading of other content types based on scrolling or user interaction. This includes dynamically loading additional sections, modules, or components of a web page as the user scrolls down or interacts with the page. By implementing lazy loading in this manner, unnecessary content is not loaded until it is needed, optimizing the initial load time and reducing the memory footprint of the page. The specific implementation may vary depending on the structure and requirements of the web application, but it generally involves event handling and conditional loading based on scroll positions or user-triggered actions.

It’s Really not that Complicated.

You can actually understand what’s going on inside your live applications. It’s a registration form away.

Get Lightrun

Lets Talk!

Looking for more information about Lightrun and debugging?
We’d love to hear from you!
Drop us a line and we’ll get back to you shortly.

By submitting this form, I agree to Lightrun’s Privacy Policy and Terms of Use.