懒加载的3种实现方式

优势

  1. 性能收益:浏览器加载图片、decode、渲染都需要耗费资源,懒加载能节约性能消耗,缩短onload事件时间。
  2. 节约带宽:这个不需要解释。
  3. 懒加载和预加载

通常,我们在html中展示图片,会有两种方式:

  1. img 标签
  2. css background-image

img的懒加载实现

img有两种方式实现懒加载:

  1. 事件监听(scroll、resize、orientationChange)

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>event</title>
    <style>
        img {
            background: #F1F1FA;
            width: 400px;
            height: 300px;
            display: block;
            margin: 10px auto;
            border: 0;
        }
    </style>
</head>
<body>
    <img src="image1.jpg?tr=w-400,h-300" />
    <img src="image2.jpg?tr=w-400,h-300" />
    <img src="image3.jpg?tr=w-400,h-300" />
    <img class="lazy" src="image2.jpg?tr=w-400,h-300" />
    <img class="lazy" src="image3.jpg?tr=w-400,h-300" /> -->
    <img class="lazy" src="image4.jpg?tr=w-400,h-300" />
    <img class="lazy" src="image5.jpg?tr=w-400,h-300" />
    <img class="lazy" src="image6.jpg?tr=w-400,h-300" />
    <img class="lazy" src="image7.jpg?tr=w-400,h-300" />
    <img class="lazy" src="image8.jpg?tr=w-400,h-300" />
    <img class="lazy" src="image9.jpg?tr=w-400,h-300" />
    <img class="lazy" src="image10.jpg?tr=w-400,h-300" />
    <script>
        document.addEventListener("DOMContentLoaded", function() {
            var lazyloadImages = document.querySelectorAll("img.lazy");    
            var lazyloadThrottleTimeout;
            
            function lazyload () {
                if(lazyloadThrottleTimeout) {
                    clearTimeout(lazyloadThrottleTimeout);
                }    
                
                lazyloadThrottleTimeout = setTimeout(function() {
                    var scrollTop = window.pageYOffset;
                    lazyloadImages.forEach(function(img) {
                        if(img.offsetTop < (window.innerHeight + scrollTop)) {
                            img.src = img.dataset.src;
                            img.classList.remove('lazy');
                        }
                    });
                    if(lazyloadImages.length == 0) {
                        document.removeEventListener("scroll", lazyload);
                        window.removeEventListener("resize", lazyload);
                        window.removeEventListener("orientationChange", lazyload);
                    }
                }, 20);
            }
            
            document.addEventListener("scroll", lazyload);
            window.addEventListener("resize", lazyload);
            window.addEventListener("orientationChange", lazyload);
        });
    </script>
</body>
</html>
  1. Intersection Observer(兼容性问题)

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>observer</title>
    <style>
        img {
            background: #F1F1FA;
            width: 400px;
            height: 300px;
            display: block;
            margin: 10px auto;
            border: 0;
        }
    </style>
</head>
<body>
    <img src="image2.jpg?tr=w-400,h-300" />
    <img src="image3.jpg?tr=w-400,h-300" /> -->
    <img class="lazy" src="image1.jpg?tr=w-400,h-300" />
    <img class="lazy" src="image2.jpg?tr=w-400,h-300" />
    <img class="lazy" src="image3.jpg?tr=w-400,h-300" />
    <img class="lazy" src="image4.jpg?tr=w-400,h-300" />
    <img class="lazy" src="image5.jpg?tr=w-400,h-300" />
    <img class="lazy" src="image6.jpg?tr=w-400,h-300" />
    <img class="lazy" src="image7.jpg?tr=w-400,h-300" />
    <img class="lazy" src="image8.jpg?tr=w-400,h-300" />
    <img class="lazy" src="image9.jpg?tr=w-400,h-300" />
    <img class="lazy" src="image10.jpg?tr=w-400,h-300" />
    <script>
        document.addEventListener("DOMContentLoaded", function() {
            var lazyloadImages = document.querySelectorAll(".lazy");
            var imageObserver = new IntersectionObserver(function(entries, observer) {
                entries.forEach(function(entry) {
                    if (entry.isIntersecting) {
                        var image = entry.target;
                        image.src = image.dataset.src;
                        image.classList.remove("lazy");
                        imageObserver.unobserve(image);
                    }
                });
            });
            lazyloadImages.forEach(function(image) {
                imageObserver.observe(image);
            });
        });
    </script>
</body>
</html>

background-image的实现

background-image的实现跟img的原理基本是一样的,区别是在对class的处理上:


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>background</title>
    <style>
        body {
            margin: 0;
        }
        .bg {
            height: 200px;
        }
        #bg-image.lazy {
            background-image: none;
            background-color: #F1F1FA;
        }
        #bg-image {
            background-image: url("image1.jpg?tr=w-400,h-300");
            background-size: 100%;
        }
    </style>
</head>
<body>
    <div id="bg-image" class="bg lazy"></div>
    <div id="bg-image" class="bg lazy"></div>
    <div id="bg-image" class="bg lazy"></div>
    <div id="bg-image" class="bg lazy"></div>
    <div id="bg-image" class="bg lazy"></div>
    <div id="bg-image" class="bg lazy"></div>
    <div id="bg-image" class="bg lazy"></div>
    <div id="bg-image" class="bg lazy"></div>
    <script>
        document.addEventListener("DOMContentLoaded", function() {
            var lazyloadImages = document.querySelectorAll(".lazy");
            var imageObserver = new IntersectionObserver(function(entries, observer) {
                entries.forEach(function(entry) {
                    if (entry.isIntersecting) {
                        var image = entry.target;
                        image.classList.remove("lazy");
                        imageObserver.unobserve(image);
                    }
                });
            });
            lazyloadImages.forEach(function(image) {
                imageObserver.observe(image);
            });
        });
    </script>
</body>
</html>

渐进式懒加载

渐进式懒加载,指的是存在降级处理,通常html形式如下:


<a href="full.jpg" class="progressive replace">
  <img src="tiny.jpg" class="preview" alt="image" />
</a>

这样的代码会有2个好处:

  1. 如果js执行失败,可以点击预览
  2. 大小与实际图一致的占位data URI,避免reflow

最终的代码如下:


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>progressive</title>
    <style>
        a.progressive {
            position: relative;
            display: block;
            overflow: hidden;
            outline: none;
        }
        a.progressive:not(.replace) {
            cursor: default;
        }
        a.progressive img {
            display: block;
            width: 100%;
            max-width: none;
            height: auto;
            border: 0 none;
        }
        a.progressive img.preview {
            filter: blur(2vw);
            transform: scale(1.05);
        }
        a.progressive img.reveal {
            position: absolute;
            left: 0;
            top: 0;
            will-change: transform, opacity;
            animation: reveal 1s ease-out;
        }
        @keyframes reveal {
            0% {transform: scale(1.05); opacity: 0;}
            100% {transform: scale(1); opacity: 1;}
        }
    </style>
</head>
<body>
    <a href="nature5.jpg" data-srcset="https://s3-us-west-2.amazonaws.com/s.cdpn.io/123941/nature5.jpg 800w, nature5big.jpg 1600w" class="progressive replace">
        <img src="https://img-blog.csdnimg.cn/2022010702521913822.jpeg" class="preview" alt="palm trees" />
    </a>
    <a href="nature2.jpg" class="progressive replace">
        <img src="http://lorempixel.com/20/15/nature/2/" class="preview" alt="sunset" />
    </a>
    <a href="nature3.jpg" class="progressive replace">
        <img src="http://lorempixel.com/20/15/nature/3/" class="preview" alt="tide" />
    </a>
    <a href="nature5.jpg" data-srcset="https://s3-us-west-2.amazonaws.com/s.cdpn.io/123941/nature5.jpg 800w, nature5big.jpg 1600w" class="progressive replace">
        <img src="https://img-blog.csdnimg.cn/2022010702521913822.jpeg" class="preview" alt="palm trees" />
    </a>
    <a href="nature2.jpg" class="progressive replace">
        <img src="http://lorempixel.com/20/15/nature/2/" class="preview" alt="sunset" />
    </a>
    <a href="nature3.jpg" class="progressive replace">
        <img src="http://lorempixel.com/20/15/nature/3/" class="preview" alt="tide" />
    </a>
    <script>
        window.addEventListener('load', function() {
            var pItem = document.getElementsByClassName('progressive replace'), timer;

            window.addEventListener('scroll', scroller, false);
            window.addEventListener('resize', scroller, false);
            inView();

            function scroller(e) {
                timer = timer || setTimeout(function() {
                    timer = null;
                    requestAnimationFrame(inView);
                }, 300);
            }

            function inView() {
                var scrollTop = window.pageYOffset;
                var innerHeight = window.innerHeight;
                var p = 0;
                while (p < pItem.length) {
                    var offsetTop = pItem[p].offsetTop;
                    if (offsetTop < (scrollTop + innerHeight)) {
                        loadFullImage(pItem[p]);
                        pItem[p].classList.remove('replace');
                    }
                    else p++;
                }
            }


            function loadFullImage(item) {
                var img = new Image();
                if (item.dataset) {
                    img.srcset = item.dataset.srcset || '';
                    img.sizes = item.dataset.sizes || '';
                }
                img.src = item.href;
                img.className = 'reveal';
                if (img.complete) addImg();
                else img.onload = addImg;

                function addImg() {
                    item.addEventListener('click', function(e) { e.preventDefault(); }, false);
                    item.appendChild(img).addEventListener('animationend', function(e) {
                        var pImg = item.querySelector('img.preview');
                        if (pImg) {
                            e.target.alt = pImg.alt || '';
                            item.removeChild(pImg);
                            e.target.classList.remove('reveal');
                        }
                    });
                }

            }

        }, false);
    </script>
</body>
</html>

现成库

推荐下面这个库,使用非常简单:https://www.npmjs.com/package/lozad

https://segmentfault.com/a/1190000017795499来源:

  • 0
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
### 回答1: Webpack懒加载是一优化前端性能的技术,可以减少初始加载文件的大小,从而提高页面加载速度。通常,当页面加载时,所有的JS代码都会被一次性加载并执行。但是,如果我们将某些模块延迟加载,只有在需要时才加载,那么就可以减少初始加载的文件大小。 Webpack提供了一个import()方法,用于动态地加载模块,它会返回一个Promise对象,可以在resolve时获取到模块的导出对象。使用这个方法,我们可以将模块的加载延迟到需要使用的时候再加载,这就是Webpack懒加载的原理。 以下是一个使用Webpack懒加载的示例: ``` import('./module').then(module => { // 使用模块 }); ``` 在上面的示例中,当代码执行到import()时,会异步地加载'module'模块,加载完成后,会执行then()中的回调函数,我们可以在回调函数中使用模块。 注意:使用Webpack懒加载时,需要确保代码可以被正确地拆分成多个文件,否则可能会导致页面加载错误。 ### 回答2: webpack懒加载是一通过代码分割实现按需加载模块的技术。当使用webpack构建项目时,所有的模块将被打包到一个文件中,然后在浏览器中加载。这意味着无论使用者需要哪些模块,都会一次性加载,这可能会导致初始加载时间过长。 懒加载通过将应用程序拆分为不同的模块,使得每个页面仅加载当前页面所需的模块,而不是加载整个应用程序。当用户访问某个页面时,只有该页面所需要的模块会被加载,其他模块则会等到需要时再进行加载。这样就能减少初始加载时间,提高页面的响应速度。 实现懒加载方式有多。一常见的方式是使用import()函数动态导入模块。import()函数会返回一个Promise对象,当该模块被加载后,Promise会被resolve。可以通过调用then()方法来执行加载完成后的回调函数。 另一方式是使用React中的Suspense组件来包裹异步加载的组件。Suspense组件可以渲染一个在组件加载完成之前显示的loading界面,等到异步组件加载完成后再进行渲染。 懒加载不仅可以减少初始加载时间,还可以按需加载不同的模块,提高应用的性能和效率。然而,懒加载也有一些注意事项。需要确保按需加载的模块之间的依赖关系正确,并且避免产生额外的网络请求。要注意合理使用懒加载,避免过度拆分导致加载过多的小模块,从而影响性能。 总结来说,webpack懒加载是一通过代码分割实现按需加载模块的技术,可以提高应用的加载速度和性能。通过合理使用懒加载方式,可以有效减少初始加载时间,提高用户体验。 ### 回答3: Webpack懒加载是指将某个模块作为一个单独的文件进行加载,而不是和其他模块一起打包到同一个初始模块中。这样可以在需要时才加载该模块,而不是在初始加载时就加载所有模块。 懒加载的主要优势在于减少初始加载时的文件大小和加载时间。当网页打开时,只需要加载初始模块,而其他模块则在实际需要时再进行加载。这样可以提升网页的加载速度和用户体验,特别是对于大型应用程序。 在Webpack中实现懒加载可以通过使用import函数的动态导入语法来实现。例如,在需要懒加载的地方使用类似于import('module')的语法来导入模块。Webpack会将该模块打包为一个单独的文件,并在需要时进行异步加载。 需要注意的是,懒加载需要配合Webpack的代码分离功能来使用。通过配置Webpack的optimization.splitChunks参数,可以将重复引用的模块提取出来,生成共享的模块文件。这样可以避免在懒加载时重复加载已经存在的模块。 除了使用动态导入语法外,Webpack还提供了其他的技术来实现懒加载,如按需加载的require.ensure语法和React.lazy()方法。这些方法都可以实现类似的懒加载效果。 总之,Webpack懒加载是一优化网页加载性能的重要技术。它通过将复杂的应用程序划分为多个模块文件,在需要时再进行加载,从而减少初始加载时间和文件大小,提升用户体验。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值