The pattern of content consumption has shifted heavily towards images in recent years. A whopping 9900% increase in visual information since 2007 signals this reality.

Whether you’re building a website or an e-commerce store, images are crucial. But large images that take lots of time to load do more harm than good. Slowly loading images slows-down the loading speed of your webpage, consequently motivating people to bounce off.

With lazy loading images, you can avoid this altogether.

The lazy loading technique allows you to add as many images as you wish without slowing down your page speed. This blog is a deep dive into the concept of lazy load images and how you can make the best out of this technique.

What Are Lazy Load Images?

The concept of lazy images allows images to load later instead of loading along with the whole page. This web development technique helps load the images only when required, i.e., when the user reaches the viewpoint.

It assists in optimizing the use of data by augmenting performance, decreasing expenses, and better utilization, which overall results in faster loading of the pages.

Types of Lazy Loading

You can use the lazy loading technique in three ways and here’s an insight into these methods.

1st Method - Lazy Load Images with the Loading Attribute (Easy)

Cross-platform web browsers like Chrome use this method to load images based on their priority.

The images placed at the viewport of the device are given the highest priority and fetched first. On the other hand, the images below the viewport are given low priority and loaded after the high priority images.

So, to lazy load images with Loading Attributes, the first step is to delay the loading of the image. To that end, the browser tries to find the ‘src’ attribute of the <img> tag for any image to get loaded. Irrespective of the first or the last image is detected, then the image will get loaded.

We have to put the image in some tag other than src. Then the next step is to set the trigger point to tell the browser when to load the image.

For the triggering purpose, the loading attribute will play the main part. The loading attribute defines whether a browser should load an image instantly or delay loading images not in the viewport until the condition is satisfied or the user scrolls near the picture.

Syntax Example:

<img data-src="URL" loading= “lazy">

Native Lazy Load Working

This feature in Chrome 76 compatible browsers enables them to lazy load images without any JavaScript help.

In other words, the programmer will not have to specify loading=lazy, but still, the images will be lazy loaded automatically by the browser. It also offers you the authority over when your images should load in the iframe.

Syntax Example:

<img src=”hello world.jpg” loading=”lazy” alt=”Hello” />

<iframe src=”Hello-Cache-Basics.html” loading=”lazy”></iframe>

Features Of Loading Attribute

Loading attributes is capable of taking three values—

  • Lazy: used for lazy loading
  • Eager: Used to load instantly without any delay
  • Auto: lets the browser choose whether to lazy or eager load

2nd Method - Lazy Load Images with Intersection Observer API (Mediocre)

Intersection Observer API is a modern interface that aids in asynchronously scrutinizing variations in the intersection of a goal component with an ancestor element or a top-level document's viewport.

They came into the picture because of the high demand for viewpoint-based functions. One main advantage of using this method is that the web page’s response time would be lesser and the user will not have a sluggish experience while scrolling.

How to use it

You can do it in three simple steps—

  1. Add image reference to the src attribute.
  2. Attach the lazy loading image's URL for lazy to a data-src attribute.
  3. If the image reaches the viewport, then replace the contents of src with the one in data-src using its intersecting property.

CSS Method

For lazy loading an image with the CSS background, there is a need to create a DOM tree and a CSSOM tree by the browser. The trees are a utility as they help determine if the CSS style applies to the document.

This is important to check because if the rule does not apply, the background image will not be loaded; otherwise, it will be loaded. So, we dupe the browser not to load the image until it is in the viewpoint or near it.

Real-world Applications

Some real applications for this method include the following.

  • Auto-pause video, when it is out of the viewport

So, if we are playing any video and want to pause the same when you scroll up or down the screen, then to do so, we could employ the IntersectionObserver. To do so, you have to set the threshold as one and leave both root and root margin at their default value. The callback will be triggered after the intersection.

  • Lazy load images

For lazy loading images, first, we will define the placeholder image to be manifested initially. Then we save the URL of the original image we want to display in the data attribute.

Intersection information-carrying entities and the observer are the two parameters that the callback function has. And the image elements become the target which the observer observes. Observation happens only till the placeholder is substituted by the original image in the image element.

  • Check on how much content is already read or scrolled through

Checking on how much content the user has gone through on the page can be found in many ways. For instance, if we consider that the user has reached the bottom of the page, then the article is fully read.

This can be achieved by increasing the view count dummy every time the user reaches the bottom of the article. Once the intersections are numbered, then they can be unobserved.

Features of Intersection Observer API

The Intersection Observers are objects used to observe the passing across an element through one of its ancestor's elements or the viewport.

Two parameters are required for the construction of the IntersectionObserver object's constructor. First is the callback function, which is executed when the observer observes any intersection. The second is an object called options, which defines the intersection.

Options has three properties:

  1. Threshold: Represented by an array of values between 0 to 1, signifying the distance of the intersection so that callback is triggered.
  2. Root: the viewport or ancestor element, which the observed element will intersect.
  3. RootMargin: Here, the area of the root element is either increased or decreased to find the area near of interaction.

Example: If the threshold is 0.7 s, then the callback will be invoked if the element passes the 70% threshold.

3rd Method - Lazy Load Images with JavaScript (Hard)

This method is the longest and hardest of them all and is more prone to errors but still very efficient and gives high speed. The use of loops, conditions, and event handlers is what makes it tough to program because due to them the code becomes long and is difficult to check, find mistakes and correct them.

Usage of Lazy Load JavaScript for High-Speed Performance’

Here, the image is first loaded on the webpage using <img> tag and src attribute. Then the src is replaced by data-src to prevent the webpage from instantly loading the image.

The next step is to choose the trigger point to start the loading of the image. The trigger can be scrolling or anything else you want. Then we have to apply the condition that if the trigger is true, then src should have the content of data-src, and the image will load.

JavaScript Libraries and Its Usage

JavaScript libraries are utilized for developing back-end APIs as they provide the ease of using shortcuts and preloaded standardized programs.

The most prominent benefit is that they are easy to use and are compatible with many platforms. Its suggestions, tricks, standardized framework, and security make it even more popular amongst programmers.

Integration of Intersection Observer API and JavaScript

The integration of Intersection Observer API and JavaScript can be done by the following steps:

  1. Define <img> tag with two lazy attributes, i.e., src for original image and data-src for lazy loading
  2. Use imageObserver and array of elements in the viewpoint as the argument for creating an instance of the Intersection observer.
  3. Create a loop and check if the entry is intersecting the viewport, and if so, then set src to the value of data-src.
  4. Observe and lazy load images using ImageObserver for detecting the intersection at the viewport.
  5. Verify the working by creating an index.html file.

Benefits of Lazy Loading Images

You might be wondering if lazy loading is actually necessary for you. When it comes to speeding up and optimizing your site, there’s nothing better than lazy load images. Here are some merits of lazy loading images you do not want to miss out on!

Loading Time Improvement

Picture-heavy websites take longer to load. The quantity of image data must be entirely downloaded before the page is fully useable.

The problem will be fixed if we lazy load our photos instead. How come? This is because only those above the fold will load in the first case. This will also result in a significant reduction in first-page load time.

Reduction in Costs

Like any other resource delivery, image delivery is often charged based on the number of bytes sent. If a picture is not visible, it is never fetched using lazy loading. That’s the best part!

As a result, you minimize the overall number of bytes sent on the page. This reduced number of bytes sent from your delivery network lowers delivery expenses.

Hardware Resources Lowered

The basic concept of slow loading is straightforward. Its purpose is to postpone loading anything that isn't required right now. For pictures below the fold, you must always utilize lazy loading. Lazy Loading Images reduces the amount of hardware needed to handle extra requests.

Enhancement of User Experience

When compared to a page that does not use lazy loading, the page becomes useable considerably faster. It enhances user experience and reduces network traffic.

Fewer resource queries result in fewer bytes to download. It is also ideal for those who have a restricted amount of network bandwidth.

Applications of Lazy Loading Images

Application in JavaScript

You may use JavaScript to verify if <img> elements. These are in the viewport to polyfill lazy-loading.

You add the observer to all of the pictures that will be lazily loaded. When the API detects that the element has entered the viewport, use the Intersecting property. This is to choose the URL from the data-src attribute. Then shift it to the src attribute so that the browser may load the picture.

Application in React

When media is loaded, React-lazy-load doesn't manage transition animations. The content mostly appears on the screen.

To handle each image state, you will create an image loader component called ImageLoader. Create and implement custom CSS3 animations for content introduction to the ImageLoader component.

Application in Angular

For Angular, the ng-defer-load library will be used to load pictures lazily. Ng-defer-load is an Angular directive that allows items to be loaded slower.

It checks if an element is in the viewport using the Intersection Observer API. It then falls back to the scroll detection method for incompatible browsers.  

The Implementation of Lazy Loading

There are four main types of lazy loading implementation patterns:

Virtual Proxy

A memory-saving technique aimed at recommending the postponement of any object creation is the virtual proxy pattern. It keeps the object postponed until required to deal with memory consumption.

Virtual proxy is normally used when the object utilizes a substantial amount of memory. Moreover, it is also implemented on objects that take up extra processing power.

Ghost

When an object is loaded in a partial state, it corresponds to its original form - this is referred to as a ghost pattern. It can even remain empty or have a UID or unloaded fields. Consequently, accessing these fields will activate this pattern.

Value Holder

A generic object capable of handling the behavior of lazy loading is a value holder. It usually appears as a replacement to the data fields when accessed.

It uses the GetValue method to generate the value of an object. Consequently, getting loaded from a service or a database before presenting itself.

Lazy Initialization

The technique that uses the value checking method for a class field is lazy initialization. Furthermore, it only gets used when the field is in use. When the value is null, that is when the field loads the proper value before returning.

Commonly Used Lazy Loading Libraries

The JavaScript libraries mentioned will help in the lazy loading of large web content:

  • Vimeo LazyLoad - Used to load Vimeo videos when the user takes action.
  • Responsive image LazyLoad JS library (Lazysizes) - Used by high-performance websites to minimize bandwidth and enhance the page load time. It delays image loading until the image comes into view.
  • YouTube LazyLoad - Enhances the web page performance but delays the video player.
  • Progressive image Lazy Loading using blur effect - Used to load images with a blurred or progressively low resolution.
  • LazyLoad.js - A pure JavaScript library used to lazy load images without dependency. By utilizing the srcset attribute, it uses a progressive JPEG file format.
  • Lozad - A 569B minified gzipped library lazy loads HTML elements with the help of Intersection Observer Web API.

With the help of these JavaScript libraries, users can optimize any webpage.

Summing It Up

In the above sections, we discussed lazy loading, different methods to implement it, its applications, benefits, and much more. It helps in significantly enhancing user experience by cutting costs, reduce page size and loading times.  So, do implement lazy loading correctly and see the advantages yourself.