描述

对视图内的 html 中的图片进行懒加载，支持默认加载占位图，加载错误图片。像网上成熟的方案 都是基于 vue、react 这样组件化进行懒加载的，有些场景下是 需要自己通过 js 运算得出，比如文章页面，后端返回的是一串html代码，这时候很难用 vue、react 这样组件化进行懒加载。
考虑到该方法大小有 60kb（主要里面包含了 base64 图片），故将其抽离至拓展中。

1.示例

文| 指南者留学学员Z
港大工业工程与物流管理在读

 

嗨，大家好，我是20fall的z学长，就读于港大ielm，一切顺利的话将在今年12月份毕业。在一整年的学习生活中，我上半年去香港上课，下半年返回大陆先后在虾皮和腾讯做了两份实习。那么在第二学期即将结束之时，让我来对我这一年的感受和思考做一个小小的总结吧。

 

 

一、专业介绍

 

 

首先，先给大家介绍以下我就读的专业，ielm中文名称是工业工程与物流管理，这是一个“多元”的专业。

 

为什么说他多元呢，因为申请这个专业的人背景十分多元，大家本科来自于不同的专业，并不是像大家想象的都是本科学物流的。其次，大家的去向也很多元，有的同学去了金融投行，有的去了互联网，有的去了国企央企，有的做了老师或公务员。

 

01 租房

 

租房的话大多数同学都会选择合租，港大周围的房价相对来说是所有港校最高的，厅长和双人间价格在3000-4500hkd，单人间一般要5500hkd以上，当然，这只是大概的参考价格。

居民区

 

02 饮食

 

在香港日常饮食的价格其实基本上和内地深圳、上海等一线城市持平，正常一顿饭无论是食堂还是一般的小店大概三十港币。

 

自己做饭的话，水果蔬菜都可以等晚上去超市买打折的，惠康经常会有十块一盒的提子、六元一包的蔬菜。佳宝的肉真得超便宜，我们经常自己煮火锅吃，八九个人可以吃人均60不到的火锅，而且撑到爆。

 

关于饮品，大多数餐馆都会有港式奶茶，学校内的食堂通常七元一杯，奶茶店的价格基本上就是内地的价格；学校里有星巴克，港大师生购买可以打七折，每周二还有指定饮品半价活动，一般十几块就可以喝到星冰乐啦。

 

03 出行

 

在香港出行大多数都是公共交通，入学后可以申请学生八达通，乘坐港铁和巴士可以半价，这个很香，大家一定要办！毕竟来了香港，谁能忍住一周不出去玩几趟呢。建议大家出行尽量不要选择的士，因为真得有点贵，还会有空调费和行李费！

 

04 购物

 

香港真的是购物天堂，一般的美妆、衣服、电子产品的价格都要比大陆低，而且货源充足，很多在大陆要抢的价格炒得比发行价高很多的产品，在香港基本上都可以买到（至少不会把价格抬得那么过分）。

 

这里分享一个香港购物省钱的好方法：在香港购物除了商场本身的折扣和汇率外，有很多商场会发很多满减购物券，比如时代广场和崇光等等，基本上等同于五折。这些购物券很多留学群都有人在卖，大家购物之前可以先了解一下~

<template>
  <div
    class="col-md-9 col-sm-12"
    style="padding-left: 40px !important; padding-right: 35px !important; height: 400px; overflow-y: auto; background: #f9f9f9"
    ref="scrollView"
  >
    <div class="article" ref="article">
      <img
        width="728"
        height="939"
        data-src="https://info.compassedu.hk/info_imgUrl_phpxpCqRL"
        style="height: auto; width: 335px; margin: 0.4rem auto; opacity: 1"
        src="https://info.compassedu.hk/1"
      />

      <div
        style="width: 350px; height: 400px; overflow-x: auto; overflow-y: hidden; background-color: red; padding: 10px"
        ref="hreizonal"
      >
        <div style="height: 100%; box-sizing: border-box; white-space: nowrap" ref="hreizonal___wrap">
          <img
            src="http://config.compassedu.hk/vote/2090_1609306071213.png"
            style="display: inline-block; margin-right: 12px"
          />
          <img
            src="https://info.compassedu.hk/info_imgUrl_phpt9vgnE"
            style="display: inline-block; margin-right: 12px"
          />
          <img
            v-for="(item, index) in imgs"
            :key="index"
            :src="item.url"
            ref="img"
            style="display: inline-block; margin-right: 12px"
          />
        </div>
      </div>

      <img v-for="(item, index) in imgs" :key="index" :src="item.url" ref="img" />

      <div class="article__wrap">
        <div class="article__scrollwrap">
          <!---->
          <div class="article__content">
            <div class="content__html">
              <p style="text-align: justify">
                <strong>文|</strong>
                <span style="text-decoration: underline"
                  ><span style="color: #1890ff; text-decoration: underline"
                    ><a
                      style="color: #1890ff; text-decoration: underline"
                      href="http://www.compassedu.hk/"
                      target="_blank"
                      rel="noopener"
                      >指南者留学</a
                    ></span
                  ></span
                >学员Z<br /><strong
                  ><a href="http://www.compassedu.hk/majr_1568" target="_blank" rel="noopener"
                    ><span style="text-decoration: underline; color: #1890ff">港大工业工程与物流管理</span></a
                  ></strong
                >在读
              </p>
              <p style="text-align: justify">&nbsp;</p>
              <p style="text-align: justify">
                嗨，大家好，我是20fall的z学长，就读于港大ielm，一切顺利的话将在今年12月份毕业。在一整年的学习生活中，我上半年去香港上课，下半年返回大陆先后在虾皮和腾讯做了两份实习。那么在第二学期即将结束之时，让我来对我这一年的感受和思考做一个小小的总结吧。
              </p>
              <p style="text-align: justify">
                <img
                  width="728"
                  height="939"
                  data-src="https://info.compassedu.hk/info_imgUrl_phpxpCqRL"
                  style="height: auto; width: 335px; margin: 0.4rem auto; opacity: 1"
                  src="https://info.compassedu.hk/info_imgUrl_phpxpCqRL"
                />
              </p>
              <p style="text-align: justify">&nbsp;</p>
              <p style="text-align: justify">&nbsp;</p>
              <p style="text-align: justify">
                <strong><span class="h1">一、专业介绍</span></strong>
              </p>
              <p style="text-align: justify">&nbsp;</p>
              <p style="text-align: justify">&nbsp;</p>
              <p style="text-align: justify">
                首先，先给大家介绍以下我就读的专业，ielm中文名称是<strong>工业工程与物流管理</strong>，这是一个“<strong>多元</strong>”的专业。
              </p>
              <p style="text-align: justify">&nbsp;</p>
              <p style="text-align: justify">
                为什么说他多元呢，因为<strong>申请这个专业的人背景十分多元</strong>，大家本科来自于不同的专业，并不是像大家想象的都是本科学物流的。其次，大家的<strong>去向也很多元</strong>，有的同学去了金融投行，有的去了互联网，有的去了国企央企，有的做了老师或公务员。
              </p>
              <p style="text-align: justify">&nbsp;</p>
              <p style="text-align: justify">
                <strong><span style="background-color: #8bc7ff">01 租房</span></strong>
              </p>
              <p style="text-align: justify">&nbsp;</p>
              <p style="text-align: justify">
                租房的话大多数同学都会选择合租，<strong>港大周围的房价相对来说是所有港校最高的</strong>，<strong>厅长和双人间价格在3000-4500hkd，单人间一般要5500hkd以上</strong>，当然，这只是大概的参考价格。
              </p>
              <p style="text-align: justify">
                <img
                  width="728"
                  height="971"
                  data-src="https://info.compassedu.hk/info_imgUrl_phpfBbupG"
                  style="height: auto; width: 335px; margin: 0.4rem auto; opacity: 1"
                  src="https://info.compassedu.hk/info_imgUrl_phpfBbupG"
                />
              </p>
              <p style="text-align: center"><span class="h6">居民区</span></p>
              <p style="text-align: justify">&nbsp;</p>
              <p style="text-align: justify">
                <strong><span style="background-color: #8bc7ff">02 饮食</span></strong>
              </p>
              <p style="text-align: justify">&nbsp;</p>
              <p style="text-align: justify">
                在香港日常饮食的价格其实基本上和内地深圳、上海等一线城市持平，<strong>正常一顿饭无论是食堂还是一般的小店大概三十港币</strong>。
              </p>
              <p style="text-align: justify">&nbsp;</p>
              <p style="text-align: justify">
                自己做饭的话，水果蔬菜都可以等晚上去超市买打折的，惠康经常会有十块一盒的提子、六元一包的蔬菜。佳宝的肉真得超便宜，我们经常自己煮火锅吃，八九个人可以吃人均60不到的火锅，而且撑到爆。
              </p>
              <p style="text-align: justify">&nbsp;</p>
              <p style="text-align: justify">
                关于饮品，大多数餐馆都会有港式奶茶，学校内的食堂通常七元一杯，奶茶店的价格基本上就是内地的价格；学校里有星巴克，港大师生购买可以打七折，每周二还有指定饮品半价活动，一般十几块就可以喝到星冰乐啦。
              </p>
              <p style="text-align: justify">
                <img
                  width="728"
                  height="970"
                  data-src="https://info.compassedu.hk/info_imgUrl_php7BqHeK"
                  style="height: auto; width: 335px; margin: 0.4rem auto; opacity: 1"
                  src="https://info.compassedu.hk/info_imgUrl_php7BqHeK"
                />
              </p>
              <p style="text-align: justify">&nbsp;</p>
              <p style="text-align: justify">
                <strong><span style="background-color: #8bc7ff">03 出行</span></strong>
              </p>
              <p style="text-align: justify">&nbsp;</p>
              <p style="text-align: justify">
                在香港出行大多数都是公共交通，入学后可以申请学生八达通，<strong>乘坐港铁和巴士可以半价</strong>，这个很香，大家一定要办！毕竟来了香港，谁能忍住一周不出去玩几趟呢。建议大家<strong>出行尽量不要选择的士</strong>，因为真得有点贵，还会有空调费和行李费！
              </p>
              <p style="text-align: justify">
                <img
                  width="728"
                  height="523"
                  data-src="https://info.compassedu.hk/info_imgUrl_phpt9vgnE"
                  style="height: auto; width: 335px; margin: 0.4rem auto; opacity: 1"
                  src="https://info.compassedu.hk/info_imgUrl_phpt9vgnE"
                />
              </p>
              <p style="text-align: justify">&nbsp;</p>
              <p style="text-align: justify">
                <strong><span style="background-color: #8bc7ff">04 购物</span></strong>
              </p>
              <p style="text-align: justify">&nbsp;</p>
              <p style="text-align: justify">
                香港真的是购物天堂，一般的美妆、衣服、电子产品的价格都要比大陆低，而且货源充足，很多在大陆要抢的价格炒得比发行价高很多的产品，在香港基本上都可以买到（至少不会把价格抬得那么过分）。
              </p>
              <p style="text-align: justify">&nbsp;</p>
              <p style="text-align: justify">
                这里分享一个<strong>香港购物省钱的好方法</strong>：在香港购物除了商场本身的折扣和汇率外，有很多商场会发很多<strong>满减购物券</strong>，比如时代广场和崇光等等，基本上等同于五折。这些购物券很多留学群都有人在卖，大家购物之前可以先了解一下~
              </p>
              <p style="text-align: justify">
                <img
                  width="728"
                  height="970"
                  data-src="https://info.compassedu.hk/info_imgUrl_phpdszGAn"
                  style="height: auto; width: 335px; margin: 0.4rem auto; opacity: 1"
                  src="https://info.compassedu.hk/info_imgUrl_phpdszGAn"
                />
              </p>
            </div>
          </div>
          <!---->
          <div class="fixedPlacehpler" style="height: 1rem; background: transparent"></div>
        </div>
      </div>
    </div>
  </div>
</template>

<script>
import lazyLoadImg from 'sf-utils2/lib/expand/lazyLoadImg'

export default {
  data() {
    return {
      imgs: [...new Array(100)].map(v => ({
        url: 'https://info.compassedu.hk/info_imgUrl_php7BqHeK?_t=' + Math.random().toString(16).slice(2)
      }))
    }
  },

  mounted() {
    this._lazyImg = lazyLoadImg({
      imgWrapDOM: this.$refs.article,
      scrollView: this.$refs.scrollView
    })
    this._lazyImg.start()
  },

  beforeDestroy() {
    this._lazyImg && this._lazyImg.end() // 关闭监听
  }
}
</script>

显示代码 复制代码 复制代码

2.入参说明

主参数

参数	说明	类型	是否必填	默认值
imgWrapDOM	img 标签包裹的 view 视图 类型数组 或者 元素对象	NodeList HTMLElement	是	-
scrollView	滚动区域	HTMLElement	是	-
transition	是否开启过度动画 默认开启	Boolean	-	true
errorReload	图片加载是否 显示重新加载图片，默认是 true	Boolean	-	true
viewportOptions	视图选项，查看详情 👇 viewportOptions 说明	Object	-	{ "offsetTop": 0, "offsetBottom": 0, "offsetLeft": 0, "offsetRight": 0}

viewportOptions 说明

参数	说明	类型	是否必填	默认值
offsetTop	滚动区域顶部偏移	Number	-	0
offsetBottom	滚动区域底部偏移	Number	-	0
offsetLeft	滚动区域左侧偏移	Number	-	0
offsetRight	滚动区域右侧偏移	Number	-	0

实例对象方法说明

参数	说明	类型	是否必填	默认值
init	初始化	Function	-	0
start	开始进行懒加载	Function	-	0
end	结束懒加载	Function	-	0
forceUpdate	强制刷新，进行懒加载	Function	-	0

3.源码

源码，点开查看 👈

import throttle from '../base/throttle'
import getStyle from '../dom/getStyle'
import getParentScrollElement from '../dom/getParentScrollElement'
import { _requestAnimationFrame } from '../dom/_constant'
import isDomVisibleInViewport from '../dom/isDomVisibleInViewport'

/**
 * 封装视图的 懒加载图片
 * @param {NodeList | HTMLElement} imgWrapDOM img标签包裹的view视图  类型数组 或者 元素对象
 * @param {HTMLElement} scrollView 滚动区域
 * @param {Boolean}transition 是否开启过度动画 默认开启
 * @param {Boolean} errorReload 图片加载是否 显示重新加载图片，默认是true
 * @param {Object} viewportOptions
 * @returns {{elImgList: NodeListOf<HTMLElementTagNameMap[string]> | NodeListOf<Element> | NodeListOf<SVGElementTagNameMap[string]>, previewImgList: []}}
 */
function lazyLoadImg({
  imgWrapDOM,
  scrollView,
  transition = true,
  errorReload = true,
  viewportOptions = {
    offsetTop: 0,
    offsetBottom: 0,
    offsetLeft: 0,
    offsetRight: 0
  }
}) {
  if (!scrollView) {
    scrollView = document.documentElement || document.body
    console.error('[warning] scrollView没有指定滚动容器，默认使用documentElement为容器')
  }

  viewportOptions = {
    offsetTop: 0,
    offsetBottom: 0,
    offsetLeft: 0,
    offsetRight: 0,
    ...viewportOptions
  }

  const isSupportIntersectionObserver = 'IntersectionObserver' in window // 是否支持IntersectionObserver属性

  lazyLoadImg.fn = lazyLoadImg.prototype = {
    blankImgBase64: `data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg==`,
    /*强制更新*/
    forceUpdate() {
      this.init().start()
    },
    /*开始*/
    start() {
      if (isSupportIntersectionObserver) {
        this.io = new IntersectionObserver(
          ioes => {
            ioes.forEach((ioe, ioei) => {
              const el = ioe.target
              if (el.dataset.status !== 'loading') return
              const intersectionRatio = ioe.intersectionRatio
              if (intersectionRatio > 0 && intersectionRatio <= 1) {
                el.src = el.dataset.src
                if (transition) {
                  setTimeout(() => {
                    el.style.opacity = 0.75
                    el.style.transition = `opacity 0.4s ease, background-image 0.4s ease`
                  })
                }
                el.onerror = () => {
                  this.onErrorImg.call(this, el)
                  this.io.unobserve(el)
                  this._elImgListTmp.splice(ioei, 1)
                }
                el.onload = () => {
                  this.onLoadImg.call(this, el)
                  this.io.unobserve(el)
                  this._elImgListTmp.splice(ioei, 1)
                }
              }
            })
          },
          {
            root: scrollView,
            rootMargin: `${viewportOptions.offsetTop}px ${viewportOptions.offsetRight}px ${viewportOptions.offsetBottom}px ${viewportOptions.offsetLeft}px`
          }
        )
        for (let i = 0; i < this._elImgListTmp.length; i++) {
          this.io.observe(this._elImgListTmp[i])
        }
      } else {
        let delay = this._elImgListTmp.length > 500 ? 300 : 150
        this.throttleScrollFn = throttle(this.onHandleScroll.bind(this), delay)
        scrollView.addEventListener('scroll', this.throttleScrollFn, false)
        setTimeout(() => {
          this.onHandleScroll.apply(this)
        }, 50)
      }
      return this
    },
    /*结束，做一些卸载的操作*/
    end() {
      if ('IntersectionObserver' in window) {
        // 关闭观察器
        this.io.disconnect()
      } else {
        scrollView.removeEventListener('scroll', this.throttleScrollFn, false)
      }
      return this
    },

    /*初始化图片*/
    readImgDOMFn(imgEleArr = []) {
      if (getStyle(scrollView, 'overflow-x') === 'auto' && getStyle(scrollView, 'overflow-Y') !== 'auto') {
        scrollView.dataset.direction = 'horizontal'
      } else {
        scrollView.dataset.direction = 'vertical'
      }
      for (let i = 0; i < imgEleArr.length; i++) {
        const el = imgEleArr[i]
        if (el.nodeType == 1) {
          if (!el.dataset.status) {
            const parentScrollView = getParentScrollElement(el)
            if (
              getStyle(parentScrollView.el, 'overflow-x') === 'auto' &&
              getStyle(parentScrollView.el, 'overflow-y') !== 'auto'
            ) {
              el.dataset.direction = 'horizontal'
            } else {
              el.dataset.direction = 'vertical'
            }
            if (!isSupportIntersectionObserver) {
              if (scrollView.dataset.direction !== el.dataset.direction) {
                el.dataset.status = 'noLazy'
                console.error(
                  `[warning] 当前环境不支持IntersectionObserver，且当前滚动容器内存在相反的垂直滚动子容器，垂直滚动子容器里的图片不进行懒加载`
                )
                continue
              }
            }
            this.previewImgList.push(el.getAttribute('src'))
            this.elImgList.push(el)
            this._elImgListTmp.push(el)
            el.dataset.status = 'loading'
            el.classList.add('lazy__img--loading')
            el.dataset.src = el.getAttribute('src')
            el.setAttribute('src', this.blankImgBase64)
            el.setAttribute('alt', el.getAttribute('alt') || '图片')
            el.style.cursor = `pointer`
            el.style.visibility = `visible`

            const parentElement = el.parentElement
            const width = el.getAttribute('width')
            const height = el.getAttribute('height')
            let wrapWidth = 0
            let wrapHeight = 0

            const maxHeight =
              parentElement.clientHeight -
              Number(getStyle(parentElement, 'padding-top').replace(/\s+|px/gi, '')) -
              Number(getStyle(parentElement, 'padding-bottom').replace(/\s+|px/gi, ''))
            const maxWidth =
              parentElement.clientWidth -
              Number(getStyle(parentElement, 'padding-left').replace(/\s+|px/gi, '')) -
              Number(getStyle(parentElement, 'padding-right').replace(/\s+|px/gi, ''))

            // 默认设置图片占位 高宽
            if (el.dataset.direction == 'horizontal') {
              wrapWidth = (maxHeight / 3) * 4
              wrapHeight = maxHeight
              if (height) {
                if (height > maxHeight) {
                  wrapHeight = maxHeight
                  height && (wrapWidth = ~~((~~wrapHeight / ~~height) * ~~width))
                } else {
                  wrapHeight = height
                  width && (wrapWidth = width)
                }
              }
              el.style.maxHeight = `${maxHeight}px`
            } else {
              wrapWidth = maxWidth
              wrapHeight = (maxWidth / 4) * 3
              if (width) {
                if (width > maxWidth) {
                  wrapWidth = maxWidth
                  height && (wrapHeight = ~~((~~maxWidth / ~~width) * ~~height))
                } else {
                  wrapWidth = width
                  height && (wrapHeight = height)
                }
              }
              el.style.maxWidth = `${maxWidth}px`
            }
            el.style.width = `${wrapWidth}px`
            el.style.height = `${wrapHeight}px`
          }
        }
      }
      return this
    },

    onLoadImg(imgDOM) {
      _requestAnimationFrame(() => {
        if (imgDOM.dataset.status === 'error' || imgDOM.dataset.status === 'reloading') return
        imgDOM.style.opacity = 1
        imgDOM.dataset.status = 'loaded'
        imgDOM.classList.remove('lazy__img--loading', 'lazy__img--error')
        if (imgDOM.dataset.direction == 'horizontal') {
          imgDOM.setAttribute('height', Number(getStyle(imgDOM, 'height').replace(/\s+|px/gi, '')))
          imgDOM.style.width = 'auto'
        } else {
          imgDOM.setAttribute('width', Number(getStyle(imgDOM, 'width').replace(/\s+|px/gi, '')))
          imgDOM.style.height = 'auto'
        }
      })
    },

    onErrorImg(imgDOM) {
      console.error(`[warning] 图片地址：${imgDOM.dataset.src} 加载失败`)
      imgDOM.setAttribute('src', this.blankImgBase64)
      imgDOM.dataset.status = 'error'
      imgDOM.style.opacity = 1
      imgDOM.classList.add(errorReload ? 'lazy__img--error-reload' : 'lazy__img--error-no-reload')
      imgDOM.classList.remove('lazy__img--loading')
      if (errorReload) {
        imgDOM.onclick = () => {
          // 重新加载
          if (imgDOM.dataset.status === 'loaded' || imgDOM.dataset.status === 'reloading') {
            return
          }
          const curTimestamp = Number(new Date())
          if (imgDOM.dataset.timestamp && curTimestamp - +imgDOM.dataset.timestamp < 50) {
            return
          }
          imgDOM.dataset.timestamp = String(curTimestamp)
          imgDOM.src = imgDOM.dataset.src
          imgDOM.dataset.status = 'reloading'
          imgDOM.classList.add('lazy__img--loading')
          imgDOM.classList.remove('lazy__img--error-reload', 'lazy__img--error-no-reload')
        }
      }
    },

    /*监听滚动*/
    onHandleScroll() {
      _requestAnimationFrame(() => {
        console.time('懒加载图片时间计算')
        this._elImgListTmp.forEach((el, eli) => {
          if (el.dataset.status === 'loading') {
            if (
              el.nodeType == 1 &&
              isDomVisibleInViewport({
                el,
                elScrollView: scrollView,
                direction: el.dataset.direction,
                ...viewportOptions
              })
            ) {
              el.src = el.dataset.src
              el.onerror = this.onErrorImg.bind(this, el)
              el.onload = this.onLoadImg.bind(this, el)
              this._elImgListTmp.splice(eli, 1)
              if (transition) {
                setTimeout(() => {
                  el.style.opacity = 0.75
                  el.style.transition = `opacity 0.4s ease, background-image 0.4s ease`
                })
              }
            }
          }
        })
        console.timeEnd('懒加载图片时间计算')
      })
    },

    /*插入loading css style*/
    insertLoadingCssStyleFn() {
      const head = document.getElementsByTagName('head')[0]
      if (!head.querySelector('style#lazy-loading__style')) {
        const styleHtml = `<style id="lazy-loading__style" type="text/css">
.lazy__img--loading{background-color:#eae9e7;border:1px solid #eeedeb;background-size:22px;background-position:center center;background-repeat:no-repeat;;background-image:url(data:image/gif;base64,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)}.lazy__img--error-reload{background-color:#eeedeb;border:1px solid #eeedeb;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAFIAAABSCAMAAADw8nOpAAAArlBMVEUAAAAAAAD///9paWkyMjL////////////29vb////09PTn5+fh4eGvr6/////6+vqZmZm8vLz39/fj4+P8/PyBgYH////////////////Gxsb////////////v7+/MzMzr6+v///+4uLj////o6OhNTU3Y2NjQ0ND9/f35+fn////////////t7e3////////////////z8/Pb29v////y8vLw8PDU1NT////////ym0LiAAAAOXRSTlMaAPooH+3z2LwFtYZ5QvXUNkvDgOAul49vV1RHGRKfWZThSPiMI2pf6szLva2ahHhPQa9wIamkYyJOAjtMAAAD1ElEQVRYw8WZ6XbaMBBGp/K+L4DBxUDZQkjInpB+7/9ipSapQPKGOT69PxNzbY3Go5FMP2rIxqPkPphrjGnz4D4ZjbO6X1QqJ2liQMJI0kk7pfW8YwD0eOrOvFBRVSX0Zu401gGw3bN1sXLyqAEsdiKSiJyYAdrj5CJlNvSBoDegEga9APCHWWOl9eQDZkSVRCbgP1nNlC8GYHtUi2cDxksDpTUEjJ/UiJ8GMLTqlO93YI5KDVEdhrv3auVYR39BF7DoQx9XKVMGW6GLUGywtFw5An7RxfwCRpKSG3vUgh53CsoUeKNWvAFpkXLM+DNe/pxsLCvfdR7HNvHU30WldQebill/Pph9ben3t/b0piwfbNxZgnKIfuHVA9dc4gS2dcLCXOpjeK58AVsUCacMEuyjSLpgeDlVWgacghGvdHDqpA4M60T5BEOVi8ItStE28vtu4IkrMx9y7XEZvvBN5+2nF0Yb94Pf5UGVHgF+9k85lGdb3eMIe/1cE8f79R2MrSLP+vBbOfEhVVwTR2wpaoqjISdeizUZ/uRL+QiTBKbIMaLCxPq6n6lKz/F4VFoaIjGOX78pS2z3mKuv4noEzcqVzwjEQLPjDFAps6PzRvhzgOdcuRPLhToXjTKb/K63ilg+dn+VE8YGYtLmo6ZKboqGPmBsclCmiIUp1QCIr7zMBw6I+RwjPSgT8V184NdWoeThscUBJgelIcy3suTDruQTB4SgRTB+UAa9KEge1dPHgRWdoSOjsRjKVz6eGtx80sVgjmmE6XkG6Tzhaljnl4bCazeiBO55EucRatYfmPLdXSR0jxmdssorQsOFUX4jZrinAJ4UyqZr5SIvckI1CmguBCPAAbfZ1HD07+cKMScNipwZm1plqIFzksYKNGI4r3r5UhBRLTOcMP/3WCpYsXJB9TjcuFzQibLlwPlaIoRegdZmeniDceTjNMaYFyfRiprg+bkxWAtJVJjqduO+EtBCIdWLX0hfbebcS3F3kZSUjU0zpbrFisSyUVLc9tTQuSCpuJWUYH9A7dCRlS0U+3bGCEbpcsa8VkoHSfmiG7dSxkgrWoPpRS7eGlQ1MG6b/c+uss1iFWsaH5fYZtU0g6XrxUzj/xKawbqW1Sx+mhX4dlNoWesba321lvvAIA8Lb5qExrq2/b/thee7vy2O2FTa/tdvUoLVzFMOdwkjvvvjcRY2KRdspZZ6g63UFRu+fc2Gr4NtaQeb5w62+B0cRHR0XHL9oU73R0/XH5B1c4zX/WEj5/f1R6LdH9xef7x8/SF410f1139Q+P+fPa74ONPBJ6Q/+TfzjGYmPq8AAAAASUVORK5CYII=);background-size:30px;background-position:center center;background-repeat:no-repeat;}.lazy__img--error-no-reload{background-color:#eeedeb;border:1px solid #eeedeb;background-image:url(data:image/png;base64,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);background-size:32px;background-position:center center;background-repeat:no-repeat;}
</style>`
        head.appendChild(document.createRange().createContextualFragment(styleHtml))
      }
      return this
    },

    /*初始化*/
    init() {
      this.throttleScrollFn = function () {}
      this.elImgList = []
      this._elImgListTmp = []
      this.previewImgList = []

      /*插入css loading 样式*/
      this.insertLoadingCssStyleFn()
      Array.isArray(imgWrapDOM)
        ? this.readImgDOMFn(
            imgWrapDOM.reduce((pre, cur) => {
              cur.querySelectorAll('img').forEach(v => {
                pre.push(v)
              })
              return pre
            }, [])
          )
        : this.readImgDOMFn(imgWrapDOM.querySelectorAll('img'))
      return this
    }
  }

  lazyLoadImg.fn.init.prototype = lazyLoadImg.fn
  return new lazyLoadImg.fn.init()
}