React · 21/84
1. 为什么推荐将静态资源放到 CDN 上 2. Class 组件的局限性 3. Class 组件与函数组件 4. Composition API 与 Hooks 对比 5. Vue 中 computed 和 watch 的区别 6. 爬楼梯问题 7. createElement 执行过程 8. 限制构造函数只能通过 new 调用 9. 判断 React 组件类型 10. 受控与非受控组件 11. 自定义 Hook 开发 12. 什么是 DNS 劫持? 13. 判断对象是否是 React 元素 14. HOC 与 Render Props 15. React 中 Element、Component、Node、Instance 的区别 16. Hooks 使用规则 17. HTTP/2 多路复用原理 18. HTTP 报文结构 19. HTTPS 握手过程 20. Immutable 在 React 中的应用 21. 实现图片懒加载 22. JavaScript == 运算符的机制 23. JavaScript 数组的内存存储方式 24. JSX 本质 25. Immutable 在 React 中的应用 26. 最大子序和 27. React Router 的 Link 和 a 标签的区别 28. JSX语法糖本质 29. 父组件调用子组件方法 30. 移动端样式适配方案 31. Portal 中的事件冒泡机制 32. React 17 新特性 33. React 18 新特性与并发渲染 34. React 组件渲染流程 35. React 是什么 36. React元素$$typeof属性 37. React 组件通信方式 38. React 错误边界处理 39. React 核心概念 40. React 组件设计 41. React Fiber 架构 42. React Hooks 原理与规则 43. React 常用 Hooks 使用指南 44. React.memo 和 memoize 函数的区别 45. React 生命周期演变 46. React 性能优化实践 47. React 性能优化策略 48. React Portals 的使用场景 49. React 中的 ref 使用 50. React 和 React-DOM 的关系 51. React 为什么不直接使用 requestIdleCallback 52. React-Router 原理与工作方式 53. React 合成事件机制 54. React 服务端渲染实现 55. React 事务机制 56. setState 同步异步问题 57. setTimeout 为什么不能保证及时执行 58. Redux 工作流与中间件 59. React 服务端渲染实现 60. 单页应用如何提高加载速度 61. Source Map 的工作原理 62. TypeScript 中的命名空间与模块 63. Taro 多端框架实现原理 64. Taro 2.x 和 Taro 3 的区别 65. TypeScript 与 JavaScript 的区别 66. TCP 三次握手和四次挥手 67. useEffect 支持 async/await 68. useEffect 闭包陷阱 69. useMemo 和 useCallback 的使用场景 70. useContext 的使用方法 71. useReducer 与 Redux 对比 72. useState 连续调用 setState 导致值丢失 73. 实现 useTimeout Hook 74. useRef、ref 和 forwardRef 的区别 75. 虚拟DOM性能分析 76. 实现 useUpdate 强制组件重新渲染 77. Virtual DOM 的意义 78. 虚拟DOM的三个组成部分 79. Virtual DOM 与 Diff 算法 80. Vue 页面渲染流程 81. Vue 与 React 对比 82. Vue 与 React 的 Diff 算法差异 83. Vue2 数组变化检测的限制与解决方案 84. Vue3 实现 Modal 组件

实现图片懒加载

使用原生 HTML、JavaScript 和 IntersectionObserver API 实现图片懒加载

问题

如何实现图片懒加载,避免一次性加载所有图片导致的性能问题和流量浪费?

解答

为什么需要懒加载

图片是影响网页性能的主要因素,一次性加载所有图片会带来两个问题:

  1. 影响用户体验,页面加载缓慢
  2. 浪费流量,用户可能不会浏览所有内容

懒加载的核心思路是:只加载可视区域内的图片,其他图片在滚动到可视区域时再加载。

方式一:HTML 原生属性

最简单的实现方式是使用 loading 属性:

<img src="./example.jpg" loading="lazy">

该属性兼容性良好,可以直接在生产环境使用。

方式二:JavaScript 实现

基本原理

  1. 图片初始时将真实地址存在 data-src 属性中,src 设为占位图
  2. 监听页面滚动,判断图片是否进入可视区域
  3. 进入可视区域后,将 data-src 的值赋给 src
<!-- 初始状态 -->
<img data-src="http://xx.com/xx.png" src="./img/default.png" />

<!-- 进入可视区域后 -->
<img data-src="http://xx.com/xx.png" src="http://xx.com/xx.png" />

背景图的实现方式类似:

<!-- 初始状态 -->
<div data-src="http://xx.com/xx.png" style="background-image: none;"></div>

<!-- 进入可视区域后 -->
<div data-src="http://xx.com/xx.png" style="background-image: url(http://xx.com/xx.png);"></div>

完整示例

HTML 结构:

<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>Lazyload</title>
    <style>
      img {
        display: block;
        margin-bottom: 50px;
        height: 200px;
        width: 400px;
      }
    </style>
  </head>
  <body>
    <img src="./img/default.png" data-src="./img/1.jpg" />
    <img src="./img/default.png" data-src="./img/2.jpg" />
    <img src="./img/default.png" data-src="./img/3.jpg" />
    <img src="./img/default.png" data-src="./img/4.jpg" />
    <img src="./img/default.png" data-src="./img/5.jpg" />
  </body>
</html>

懒加载函数:

function lazyload() {
  // 获取可视区高度
  let viewHeight = window.innerHeight || document.documentElement.clientHeight || document.body.clientHeight
  let imgs = document.querySelectorAll('img[data-src]')
  
  imgs.forEach((item) => {
    if (item.dataset.src === '') return
    
    // 获取元素相对浏览器视窗的位置
    let rect = item.getBoundingClientRect()
    if (rect.bottom >= 0 && rect.top < viewHeight) {
      item.src = item.dataset.src
      item.removeAttribute('data-src')
    }
  })
}

性能优化:节流

直接监听 scroll 事件会导致函数频繁触发,需要使用节流函数优化:

function throttle(fn, delay) {
  let timer
  let prevTime
  return function (...args) {
    const currTime = Date.now()
    const context = this
    if (!prevTime) prevTime = currTime
    clearTimeout(timer)

    if (currTime - prevTime > delay) {
      prevTime = currTime
      fn.apply(context, args)
    } else {
      timer = setTimeout(() => {
        prevTime = currTime
        fn.apply(context, args)
      }, delay)
    }
  }
}

// 使用节流函数
window.addEventListener('scroll', throttle(lazyload, 200))

方式三:IntersectionObserver API

IntersectionObserver 是浏览器原生 API,可以自动观察元素是否进入可视区域,无需手动计算位置和监听滚动事件。

基本用法:

var io = new IntersectionObserver(callback, option)

// 开始观察
io.observe(document.getElementById('example'))

// 停止观察
io.unobserve(element)

// 关闭观察器
io.disconnect()

实现图片懒加载:

const imgs = document.querySelectorAll('img[data-src]')
const config = {
  rootMargin: '0px',
  threshold: 0,
}

let observer = new IntersectionObserver((entries, self) => {
  entries.forEach((entry) => {
    if (entry.isIntersecting) {
      let img = entry.target
      let src = img.dataset.src
      if (src) {
        img.src = src
        img.removeAttribute('data-src')
      }
      // 解除观察
      self.unobserve(entry.target)
    }
  })
}, config)

imgs.forEach((image) => {
  observer.observe(image)
})

关键点

  • 使用 loading="lazy" 属性是最简单的实现方式
  • JavaScript 实现需要判断元素是否进入可视区域,使用 getBoundingClientRect() 获取位置信息
  • 监听 scroll 事件时必须使用节流函数优化性能
  • IntersectionObserver API 是更现代的解决方案,无需手动计算位置和处理滚动事件
  • 图片真实地址存储在 data-src 中,进入可视区域后再赋值给 src 属性