This content originally appeared on DEV Community and was authored by Henrique Schroeder
Optimizing web performance is crucial for providing a superior user experience, improving SEO, and increasing conversion rates. For intermediate and experienced developers, lazy loading images and components is an advanced technique that can make a significant difference in web application performance. Let's explore the more technical aspects of this practice and how to implement it efficiently using native JavaScript, lazysizes, React.lazy, Dynamic Imports, and next/script.
Advanced Benefits of Lazy Loading
-
Improvement of Largest Contentful Paint (LCP):
- LCP is one of Google's key Core Web Vitals indicators. By deferring the loading of non-critical images and components, the rendering time of the largest visible element in the initial viewport is significantly reduced.
-
Reduction of Resource Consumption:
- Lazy loading reduces the load on the server and network by avoiding unnecessary requests, improving overall system efficiency and allowing resources to be allocated more effectively.
-
Enhancement of Responsiveness:
- Applications that use lazy loading are more responsive, especially on mobile devices, providing a smoother experience for end users.
Implementation of Lazy Loading for Images with Native JavaScript
Complete Example:
- HTML:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Lazy Loading Example</title>
<style>
.lazy {
opacity: 0;
transition: opacity 0.3s;
}
.lazy-loaded {
opacity: 1;
}
</style>
</head>
<body>
<h1>Lazy Loading Example</h1>
<img data-src="image1.jpg" alt="Image 1 Description" class="lazy">
<img data-src="image2.jpg" alt="Image 2 Description" class="lazy">
<img data-src="image3.jpg" alt="Image 3 Description" class="lazy">
<script src="lazyload.js"></script>
</body>
</html>
- JavaScript (lazyload.js):
document.addEventListener("DOMContentLoaded", function() {
const lazyImages = document.querySelectorAll('img.lazy');
const lazyLoad = (image) => {
image.src = image.dataset.src;
image.onload = () => {
image.classList.remove('lazy');
image.classList.add('lazy-loaded');
};
};
if ("IntersectionObserver" in window) {
const observer = new IntersectionObserver((entries, observer) => {
entries.forEach(entry => {
if (entry.isIntersecting) {
lazyLoad(entry.target);
observer.unobserve(entry.target);
}
});
});
lazyImages.forEach(img => {
observer.observe(img);
});
} else {
// Fallback for browsers that do not support IntersectionObserver
const lazyLoadThrottle = () => {
lazyImages.forEach(img => {
if (img.getBoundingClientRect().top < window.innerHeight && img.getBoundingClientRect().bottom > 0 && getComputedStyle(img).display !== "none") {
lazyLoad(img);
}
});
};
window.addEventListener("scroll", lazyLoadThrottle);
window.addEventListener("resize", lazyLoadThrottle);
window.addEventListener("orientationchange", lazyLoadThrottle);
}
});
Implementation of Lazy Loading for Images with lazysizes
HTML:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Lazy Loading with lazysizes</title>
<style>
.lazyload {
opacity: 0;
transition: opacity 0.3s;
}
.lazyloaded {
opacity: 1;
}
</style>
</head>
<body>
<h1>Lazy Loading with lazysizes</h1>
<img data-src="image1.jpg" alt="Image 1 Description" class="lazyload">
<img data-src="image2.jpg" alt="Image 2 Description" class="lazyload">
<img data-src="image3.jpg" alt="Image 3 Description" class="lazyload">
<script src="https://cdnjs.cloudflare.com/ajax/libs/lazysizes/5.3.2/lazysizes.min.js" async></script>
</body>
</html>
Implementation of Lazy Loading for Components with React.lazy and Suspense
React:
import React, { Suspense, lazy } from 'react';
const LazyComponent = lazy(() => import('./LazyComponent'));
function App() {
return (
<Suspense fallback={<div>Loading...</div>}>
<LazyComponent />
</Suspense>
);
}
export default App;
Implementation of Lazy Loading for Components with Dynamic Imports in Next.js
Next.js:
import dynamic from 'next/dynamic';
const DynamicComponent = dynamic(() => import('../components/DynamicComponent'), {
loading: () => <p>Loading...</p>,
ssr: false
});
export default function Home() {
return <DynamicComponent />;
}
Additional Optimizations with next/script
Next.js:
import Script from 'next/script';
function MyApp() {
return (
<>
<Script src="https://example.com/somescript.js" strategy="lazyOnload" />
<Component />
</>
);
}
Final Considerations
Implementing lazy loading with native JavaScript, lazysizes, React.lazy, Dynamic Imports, and next/script is a powerful approach to improving the performance of your web applications. These techniques allow precise control over when and how resources are loaded, providing a faster and more efficient user experience.
When applying these advanced techniques, it's important to monitor performance impacts using tools like Lighthouse, Google Analytics, and Core Web Vitals reports. Continuous analysis and iterative optimization will ensure that your applications deliver the best possible experience.
References
- Google Developers: Native Lazy Loading
- MDN Web Docs: Intersection Observer API
- Web.dev: Lazy Loading
- Google Developers: Optimize LCP
- Lazysizes GitHub Repository
- React Documentation: Code Splitting
- Next.js Documentation: Dynamic Import
This content originally appeared on DEV Community and was authored by Henrique Schroeder
Henrique Schroeder | Sciencx (2024-06-21T19:08:10+00:00) Optimizing Web Performance: Lazy Loading Images and Components. Retrieved from https://www.scien.cx/2024/06/21/optimizing-web-performance-lazy-loading-images-and-components/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.