On this article, we’ll discover three use instances 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 ingredient intersects with one other. It really works by setting the callback perform to execute at any time when the goal ingredient interacts with the viewport.

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

Desk of Contents

Use Case 1: Lazy Loading for Improved Efficiency

Lazy loading is a method to defer the rendering of much less important elements (knowledge, code, pictures, movies), largely in instances the place loading all the things from the beginning is detrimental to efficiency and results in a decline in core net vitals. It will possibly considerably enhance web page loading occasions, particularly for content-heavy web sites.

Merely put, lazy loading delays the loading of sources till they change into seen within the viewport. Pictures under the fold or hidden inside scrollable content material gained’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> ingredient doesn’t present granular management over loading conduct. However the Intersection Observer lets you observe a DOM ingredient 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 occasions 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 web optimization and Google Lighthouse scores.
  • Diminished knowledge utilization. Customers on slower connections or restricted knowledge plans profit from decreased knowledge utilization as pictures load on demand.
  • Smoother scrolling. Scrolling feels extra responsive, as heavy pictures don’t obtain upfront, stopping janky web page jumps.
  • Improved person expertise. Customers see the content material they’re excited by sooner, resulting in a greater general expertise.

The best way to implement lazy loading with React Intersection Observer

To get began with our coding, we first must 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 required 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 will have a listing of pictures you need to lazy load. Now, let’s use the LazyImage part in our utility:

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

const ImageList = () => {
  const pictures = [
    { 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 (
      {pictures.map((picture) => (

export default ImageList;

The LazyImage part 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 ingredient’s visibility. The ImageList part maps over a listing of pictures, rendering a LazyImage for every one.

The next lazy loaded CodeSandbox comprises the whole working code.

Implementing lazy loading for elements with React Intersection Observer is an easy solution to increase the efficiency of your React purposes. Deferring the loading of sources till wanted gives a sooner and extra environment friendly person expertise. Think about including lazy loading into your tasks, particularly in the event that they contain substantial content material.

Infinite scrolling is a method 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 means of 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 maintain 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 means of content material with out interruptions, offering a extra participating expertise.
  • Environment friendly useful resource utilization. Sources are solely loaded when wanted, lowering pointless knowledge fetching and rendering.
  • Simplified navigation. Removes the necessity for conventional pagination hyperlinks, simplifying the navigation expertise for customers.
  • Improved efficiency. Positive-grained statement avoids pointless calculations and content material loading.
  • Elevated visibility. Metrics like Time to Interactive profit, boosting web optimization and Google Lighthouse scores.

The best way to implement infinite scrolling with React Intersection Observer

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

npm set up react-intersection-observer

Import the required 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} fashion={{ top: "10px" }} />;

export default InfiniteScroll;

Use the InfiniteScroll part 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 (
      {objects.map((merchandise) => (
        <div key={merchandise.id} className="list-item">
          {merchandise.content material}
      <InfiniteScroll loadMore={loadMore} />

export default InfiniteScrollList;

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

This Infinite Scroll CodeSandbox comprises the whole working code.

Harnessing the ability of the Intersection Observer builds you an environment friendly and fascinating infinite scrolling expertise. This method boosts efficiency, person satisfaction, and your web site’s general enchantment. Bear in mind, optimizing your scroll journey helps maintain customers hooked to your utility.

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

Animations and transitions deliver life to an internet web page, making it extra participating for customers. Nonetheless, triggering these results on the proper second will be difficult. The Intersection Observer gives 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 mounted scroll positions. The Intersection Observer unlocks a brand new degree of dynamism.

Advantages of animations and transitions with the Intersection Observer

  • Efficiency increase. 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 ingredient’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.

The best way to 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 part for dealing with intersection occasions:

import React, { useEffect } from "react";

const IntersectionAnimationTrigger = ({ kids, 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">{kids}</div>;

export default IntersectionAnimationTrigger;

Use the IntersectionAnimationTrigger part to animate when the ingredient 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 ingredient will animate because it comes into view.

export default AnimatedElement;

Add some CSS to make the animation visually interesting:

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

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

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

This Animations and Transitions Codesandbox comprises the whole working code.

For any utility function, leveraging intersection occasions enhances the visible enchantment of your challenge. Experiment with totally different animations and transitions to seek out the proper stability on 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 Pylogix:

Additional references