Friday, April 12, 2024

Management Lazy Load, Infinite Scroll and Animations in React — SitePoint

Must read

On this article, we’ll discover three use circumstances for working with the React Intersection Observer: lazy loading, infinite scrolling, and animation/transition triggers.

The React Intersection Observer aids in monitoring adjustments in a component’s viewport inside your utility. The Intersection Observer detects when a selected aspect intersects with one other. It really works by setting the callback operate to execute each time the goal aspect interacts with the viewport.

It gives a chic answer for dealing with aspect visibility and aiding you in creating dynamic purposes.

Desk of Contents

Use Case 1: Lazy Loading for Improved Efficiency

Lazy loading is a way to defer the rendering of much less vital elements (information, code, photos, movies), largely in circumstances the place loading every little thing from the beginning is detrimental to efficiency and results in a decline in core net vitals. It might considerably enhance web page loading instances, particularly for content-heavy web sites.

Merely put, lazy loading delays the loading of sources till they grow to be seen within the viewport. Photographs under the fold or hidden inside scrollable content material received’t obtain instantly, stopping pointless useful resource consumption and web page load delays.

You may lazy load with out utilizing the Intersection Observer, however the conventional onScroll occasion of the <img> aspect doesn’t present granular management over loading habits. However the Intersection Observer permits you to observe a DOM aspect and set off actions based mostly on its intersection with the viewport.

Advantages of lazy loading with React Intersection Observer

  • Sooner web page load. By deferring picture loading, preliminary web page load instances enhance, main to higher person engagement and lowering preliminary web page load time.
  • Improved core net vitals. Metrics like largest contentful paint (LCP) profit from lazy loading, boosting your app’s search engine optimisation and Google Lighthouse scores.
  • Lowered information utilization. Customers on slower connections or restricted information plans profit from diminished information utilization as photos load on demand.
  • Smoother scrolling. Scrolling feels extra responsive, as heavy photos don’t obtain upfront, stopping janky web page jumps.
  • Improved person expertise. Customers see the content material they’re inquisitive about quicker, resulting in a greater total expertise.

How one can implement lazy loading with React Intersection Observer

To get began with our coding, we first have to arrange React Intersection Observer in our React utility. You may set up the dependency utilizing the next:

npm set up react-intersection-observer

Import the mandatory elements and hooks:

import React from "react";
import { useInView } from "react-intersection-observer";

const LazyImage = ({ src, alt, className }) => {
  const [ref, inView] = useInView({
    triggerOnce: true, 

  return (
      src={inView ? src : ""}
      className={`lazy-image $ ""`}

export default LazyImage;

Integrating lazy loading into your elements

Assume you’ve gotten a listing of photos you need to lazy load. Now, let’s use the LazyImage element in our utility:

import React from "react";
import LazyImage from "./LazyImage";

const ImageList = () => {
  const photos = [
    { id: 1, src: "image1.jpg", alt: "Description 1" },
    { id: 2, src: "image2.jpg", alt: "Description 2" },
    { id: 3, src: "image3.jpg", alt: "Description 3" },
    { id: 4, src: "image4.png", alt: "Description 4" },
    { id: 5, src: "image5.png", alt: "Description 5" },
    { id: 6, src: "image6.png", alt: "Description 6" },
    { id: 7, src: "image7.png", alt: "Description 7" },
    { id: 8, src: "image8.png", alt: "Description 8" },
    { id: 9, src: "image9.png", alt: "Description 9" },

  return (
      { => (

export default ImageList;

The LazyImage element makes use of the useInView hook to find out if a component is within the viewport, using the triggerOnce possibility for a single set off. It dynamically units the src attribute of an <img> tag based mostly on the aspect’s visibility. The ImageList element maps over a listing of photos, rendering a LazyImage for each.

The next lazy loaded CodeSandbox incorporates the entire working code.

Implementing lazy loading for elements with React Intersection Observer is a simple strategy to enhance the efficiency of your React purposes. Deferring the loading of sources till wanted gives a quicker and extra environment friendly person expertise. Take into account including lazy loading into your initiatives, particularly in the event that they contain substantial content material.

Infinite scrolling is a way that enhances person expertise by loading extra content material because the person reaches the underside of a web page.

As an alternative of requiring customers to navigate by conventional pagination hyperlinks, infinite scrolling gives a seamless and steady move of content material.

By dynamically loading content material because the person reaches the underside of the web page, web sites preserve customers engaged and keep away from disruptive web page transitions.

Advantages of infinite scrolling with React Intersection Observer

  • Improved person expertise. Customers can seamlessly scroll by content material with out interruptions, offering a extra partaking expertise.
  • Environment friendly useful resource utilization. Assets are solely loaded when wanted, lowering pointless information fetching and rendering.
  • Simplified navigation. Removes the necessity for conventional pagination hyperlinks, simplifying the navigation expertise for customers.
  • Improved efficiency. Fantastic-grained commentary avoids pointless calculations and content material loading.
  • Elevated visibility. Metrics like Time to Interactive profit, boosting search engine optimisation and Google Lighthouse scores.

How one can implement infinite scrolling with React Intersection Observer

As common, add the React Intersection Observer to your React utility:

npm set up react-intersection-observer

Import the mandatory elements and hooks:

import React from "react";
import { useInView } from "react-intersection-observer";

const InfiniteScroll = ({ loadMore }) => {
  const [ref, inView] = useInView({
    triggerOnce: true,

  React.useEffect(() => {
    if (inView) {
  }, [inView, loadMore]);

  return <div ref={ref} type={{ top: "10px" }} />;

export default InfiniteScroll;

Use the InfiniteScroll element to implement infinite scrolling:

import React, { useState } from "react";
import InfiniteScroll from "./InfiniteScroll";

const initialItems = [
  { id: 1, content: "Item 1" },
  { id: 2, content: "Item 2" },
  { id: 3, content: "Item 3" },

const fetchMoreData = (web page) => {
  return Array.from({ size: 5 }, (_, index) => ({
    id: initialItems.size + index + 1,
    content material: `Merchandise ${initialItems.size + index + 1}`,

const InfiniteScrollList = () => {
  const [items, setItems] = useState(initialItems);
  const [page, setPage] = useState(1);

  const loadMore = () => {
    const newData = fetchMoreData(web page + 1);
    setItems([...items, ...newData]);
    setPage(web page + 1);

  return (
      { => (
        <div key={} className="list-item">
          {merchandise.content material}
      <InfiniteScroll loadMore={loadMore} />

export default InfiniteScrollList;

The InfiniteScroll element makes use of the useInView hook to detect its visibility, invoking the loadMore operate to load extra content material. The loadMore operate then fetches further information, appending it to the prevailing listing. The InfiniteScrollList element renders a steady scroll expertise, displaying the listing of things with dynamic loading triggered by the InfiniteScroll element.

This Infinite Scroll CodeSandbox incorporates the entire working code.

Harnessing the facility of the Intersection Observer builds you an environment friendly and interesting infinite scrolling expertise. This system boosts efficiency, person satisfaction, and your web site’s total enchantment. Keep in mind, optimizing your scroll journey helps preserve customers hooked to your utility.

Use Case 3: Animation and Transition Triggers with the Intersection Observer

Animations and transitions carry life to an online web page, making it extra partaking for customers. Nonetheless, triggering these results on the proper second might be difficult. The Intersection Observer provides an answer by permitting you to outline when a component is in view, offering a superb mechanism for triggering animations and transitions.

Gone are the times of animations firing on web page load or at fastened scroll positions. The Intersection Observer unlocks a brand new stage of dynamism.

Advantages of animations and transitions with the Intersection Observer

  • Efficiency enhance. Animations solely set off when wanted or when in view, saving sources and stopping pointless calculations.
  • Enhanced storytelling. Content material comes alive as components animate on the essential second, drawing person consideration and emphasizing key factors.
  • Responsive interactions. Completely different animations based mostly on scroll depth permit for layered storytelling and personalised experiences.
  • Clean scrolling. Transitions between states happen seamlessly, enhancing person engagement and stopping jarring interruptions.
  • Exact timing. Animation and transition triggers are based mostly on the aspect’s visibility, guaranteeing exact timing and synchronization with person interactions.
  • Enhanced person engagement. Creating visually interesting and interactive elements will increase person engagement and gives a extra dynamic person expertise.

How one can implement animations and transitions with React Intersection Observer

Once more, set up the React Intersection Observer dependency:

npm set up react-intersection-observer

Create the reusable element for dealing with intersection occasions:

import React, { useEffect } from "react";

const IntersectionAnimationTrigger = ({ youngsters, onInView }) => {
  const handleIntersection = (entries, observer) => {
    entries.forEach((entry) => {
      if (entry.isIntersecting) {

  useEffect(() => {
    const observer = new IntersectionObserver(handleIntersection, {
      threshold: 0.5,


    return () => {
  }, [onInView]);

  return <div id="animated-element">{youngsters}</div>;

export default IntersectionAnimationTrigger;

Use the IntersectionAnimationTrigger element to animate when the aspect comes into view:

import React, { useState } from "react";
import IntersectionAnimationTrigger from "./IntersectionAnimationTrigger";

const AnimatedElement = () => {
  const [animated, setAnimated] = useState(false);

  const handleInView = () => {

  return (
    <IntersectionAnimationTrigger onInView={handleInView}>
      <div className={`animated-element ${animated ? "animate" : ""}`}>
        This aspect will animate because it comes into view.

export default AnimatedElement;

Add some CSS to make the animation visually interesting:

.animated-element {
  opacity: 0;
  remodel: translateY(20px);
  transition: opacity 0.5s ease-in-out, remodel 0.5s ease-in-out;

.animated-element.animate {
  opacity: 1;
  remodel: translateY(0);
  width: 15rem;
  top: 5rem;
  margin: 0 auto;
  colour: blue;

The IntersectionAnimationTrigger element makes use of the useInView hook to trace aspect visibility, executing the onInView callback when it enters the view. Inside the AnimatedElement element, the animated state toggles to provoke the animation when the aspect turns into seen.

This Animations and Transitions Codesandbox incorporates the entire working code.

For any utility function, leveraging intersection occasions enhances the visible enchantment of your mission. Experiment with totally different animations and transitions to seek out the right stability to your private use case.


React Intersection Observer simplifies the method of lazy loading, infinite scrolling, and animation triggering by offering React-specific hooks and elements, making it simpler so that you can incorporate intersection-related performance into your React purposes. It abstracts away a number of the complexities, providing a extra declarative syntax that aligns with the component-based nature of React.

In the event you loved this React article, take a look at these different nice sources from SitePoint:

Additional references

Supply hyperlink

More articles


Please enter your comment!
Please enter your name here

Latest article