Zusammenfassung der drei Lazy-Load-Methoden lazyLoad mit nativem JS

Zusammenfassung der drei Lazy-Load-Methoden lazyLoad mit nativem JS

Vorwort

Lassen Sie uns zunächst die Seite wie folgt erstellen:

<Stil>
    * {
      Polsterung: 0%;
      Marge: 0%;
    }

    .contain img {
      Breite: 600px;
      Höhe: 400px;
    }

    ul {
      Listenstil: keiner;
    }

    li {
      Anzeige: Inline-Block;
    }
  </Stil>
  
  
  <div Klasse="enthalten">
    <ul>
       <li><img data-src="./images/iu.jpg" src='./images/lazy.png' alt=""></li>
      <li><img data-src="./images/iu1.jpg" src='./images/lazy.png' alt=""></li>
      <li><img data-src="./images/iu2.png" src='./images/lazy.png' alt=""></li>
      <li><img data-src="./images/iu3.jpg" src='./images/lazy.png' alt=""></li>
      <li><img data-src="./images/iu4.jpg" src='./images/lazy.png' alt=""></li>
      <li><img data-src="./images/iu5.jpg" src='./images/lazy.png' alt=""></li>
      <li><img data-src="./images/iu6.jpg" src='./images/lazy.png' alt=""></li>
      <li><img data-src="./images/iu7.jpg" src='./images/lazy.png' alt=""></li>
      <li><img data-src="./images/iu8.jpg" src='./images/lazy.png' alt=""></li>
      <li><img data-src="./images/iu9.jpg" src='./images/lazy.png' alt=""></li>
      <li><img data-src="./images/iu10.jpg" src='./images/lazy.png' alt=""></li>
      <li><img data-src="./images/zzf_01.jpg" src='./images/lazy.png' alt=""></li>
    </ul>
  </div
>

Wir wissen, dass das verzögerte Laden von Bildern dazu dient, festzustellen, ob das Bild den sichtbaren Bereich erreicht, wenn die Bildlaufleiste nach unten scrollt.

Daher müssen wir während der Bildlaufüberwachung feststellen, ob das Bild angezeigt werden soll. Dazu müssen wir zunächst die tatsächliche Adresse des Bildes ausblenden, d. h. das benutzerdefinierte Attribut data-src verwenden, um die tatsächliche Adresse des Bildes zu speichern, und dann die tatsächliche Adresse laden, wenn die Bildlaufleiste zu dem sichtbaren Bild scrollt.

Schauen wir uns die erste Methode an

Methode 1: Hoher Kontrast

Hier verwenden wir (die Höhe des Elements von oben - die Höhe der gescrollten Seite <= die Höhe des sichtbaren Bereichs des Browsers), um zu bestimmen, ob es die gewünschten Bedingungen erfüllt. Hier müssen wir die Höhenänderungen des Bildes überwachen, wenn die Seite in Echtzeit gescrollt wird.

/**
 * Methode 1 * Höhenkontrast */
 let imgs = [...document.querySelectorAll('img')]; // Zuerst alle Bilder abrufen window.addEventListener('scroll', function () {
   
 })

Beurteilen Sie nach dem Hinzufügen des Ereignisses weiterhin, ob das Bild den Anforderungen entspricht, d. h.

 /**
  * Methode 1 * Höhenkontrast */
  let imgs = [...document.querySelectorAll('img')]; // Zuerst alle Bilder abrufen window.addEventListener('scroll', function () {
    lazyLoad(Bilder)
  })
  Funktion lazyLoad(Bilder) {
    für (var i = 0; i < imgs.length; i++) {
      var height = imgs[i].offsetTop; // Die Höhe des Bildes vom oberen Rand aus var wheight = window.innerHeight; // Die Höhe des sichtbaren Bereichs des Browsers var sheight = document.documentElement.scrollTop; // Die Höhe der weggescrollten Seite if (height - sheight <= wheight) { // Bestimmen Sie, ob das Bild gleich erscheint imgs[i].src = imgs[i].dataset.src; // Konvertieren Sie die benutzerdefinierte Adresse in die echte Adresse, nachdem sie erscheint}
    }
  }

Sieht ziemlich einfach aus, oder? Aber wir haben eine noch einfachere Methode:

Methode 2: Verwenden Sie die API getBoundingClientRect()

Hier ist zunächst die MDN-Erklärung zu getBoundingClientRect()

Wir können getBoundingClientRect().top verwenden, um den Abstand zwischen dem Element und der Oberseite des Ansichtsfensters zu ermitteln. So können wir die Beziehung zwischen den Werten von getBoundingClientRect().top und window.innerHeight vergleichen, um den Lazy-Loading-Effekt zu erzielen. Hier werden die Attribute getAttribute() und setAttribute() verwendet.

 /**
  * Methode 2 * @params getBoundingClientRect()
  * Ansichtsfenster-API
  */

 : Lassen Sie imgs = [...document.querySelectorAll('img')];
 window.addEventListener('scrollen', Funktion () {
    imgs.forEach(img => { 
      //Dies ist eigentlich die gleiche Idee wie Methode 1, aber es ist etwas einfacher if (img.getBoundingClientRect().top < window.innerHeight) { 
     
        let dataSrc = img.getAttribute(' data-src'); // Echte Adresse von data-src abrufen img.setAttribute('src', dataSrc); // Echte Adresse durch das src-Attribut ersetzen console.log(img.src);
      }
    })
  })

Methode 3: Verwenden Sie den neuesten IntersectionObserver-Konstruktor

Glauben Sie nach dem Lesen der beiden oben genannten Methoden, dass Lazy Loading ganz einfach ist?

Ja, wir haben sehr wenig Code geschrieben und es sah einfach aus, aber wir haben ein wichtiges Problem übersehen:

Nachdem das Bild durch die echte Adresse ersetzt wurde, wird die if()-Bedingung kontinuierlich ausgelöst, wenn wir wiederholt an der Bildlaufleiste ziehen.

Also habe ich in der Methode Method2 ein console.log(img.src); eingegeben.

Der Zweck besteht darin, Ihnen zu zeigen, dass console.log(img.src) kontinuierlich gedruckt wird, wenn jemand die Bildlaufleiste weiter zieht.

Wie können wir also häufige Operationen am Bild verhindern, nachdem die echte Adresse geladen wurde? Oder wie können wir die Leistung des Browsers optimieren?

Wie es der Zufall will, gibt es jetzt einen neuen Konstruktor, der unser Problem der häufigen Auslösung bedingter Anweisungen löst.

Dieser Konstruktor ist IntersectionObserver

Laut der Erklärung auf MDN

  • Der IntersectionObserver()-Konstruktor erstellt und gibt ein IntersectionObserver-Objekt zurück. Wenn rootMargin angegeben ist, wird die Syntaxkonformität überprüft. Außerdem wird geprüft, ob die Schwellenwerte alle zwischen 0,0 und 1,0 liegen. Außerdem wird die Liste der Schwellenwerte in aufsteigender Reihenfolge sortiert. Wenn die Schwellenwertliste leer ist, wird standardmäßig ein Array von [0,0] verwendet.
  • RückrufWenn das sichtbare Verhältnis des Elements den angegebenen Schwellenwert überschreitet, wird eine Rückruffunktion aufgerufen. Diese Rückruffunktion akzeptiert zwei Parameter:
    „entrys“ ist ein Array von „IntersectionObserverEntry“-Objekten, von denen jedes mehr oder weniger vom angegebenen Schwellenwert abweicht.
    Die IntersectionObserver-Instanz, auf der der Beobachter aufgerufen wird.

Hier verwenden wir nur den ersten Parameter Callback

window.addEventListener('scrollen', Funktion () {
// Zuerst instanziieren wir diesen Konstruktor const observe = new IntersectionObserver(callback);
// Dann schreiben Sie die Callback-Funktion callback wir brauchen, um das Geschäft zu behandeln
   const callback = Einträge => {
        console.log(Einträge); //Drucken wir zuerst die Einträge aus, um zu sehen, wofür sie nützlich sind //Wie unten gezeigt};
}

window.addEventListener('scrollen', Funktion () {
   const observe = neuer IntersectionObserver(Rückruf);
// Dann schreiben Sie die Callback-Funktion callback wir brauchen, um das Geschäft zu behandeln
   const callback = Einträge => {
       // Wir stellen fest, dass es ein Array ist, also entries.forEach(ele => {
           console.log(ele); // Lassen Sie uns das Element noch einmal drucken, um zu sehen, was darin ist // wie unten gezeigt})
    };
}

Wir haben festgestellt, dass die Eigenschaft isIntersecting: false ist, was bedeutet, ob es sich überschneidet. Gemäß der Bedeutung des Konstruktors wissen wir, dass Überschneidungen so verstanden werden können, ob sie beobachtet werden.

Wenn es beobachtet wird, ersetzen wir seine reale Adresse durch sein src-Attribut und brechen seine Beobachtung ab

 /**
  * Methode 3 * @params neuer IntersectionObserver(callback[,Optionen])
  * Beobachtung-->Konstruktor*/
  window.addEventListener('scrollen', Funktion () {
    let imgs = [...document.querySelectorAll('.img')]
    const callback = entries => { // entries ist das beobachtete Element-Array entries.forEach(ele => {
            if (ele.isIntersecting) { // isIntersecting wird beobachtet const data_src = ele.target.getAttribute('data-src'); // Dies ist grundsätzlich dasselbe wie Methode1/Methode2 ele.target.setAttribute('src', data_src); // ele.target ist das Zielelement observe.unobserve(ele.target) // Beobachtung aufheben, nachdem die echte Adresse ersetzt wurde }
        })
    };
    const observe = neuer IntersectionObserver(callback); // IntersectionObserver instanziieren
    imgs.forEach(Bild => { 
        observe.observe(image) // observe: Die aufgerufene IntersectionObserver-Instanz. Fügen Sie jedem Bild Beobachtungsinstanzen hinzu})
  }

Auf diese Weise können wir die bedingte if()-Anweisung nicht mehr häufig auslösen.

Denn nachdem das Bild die reale Adresse ersetzt hatte, habe ich die Beobachtung des aktuellen Bildes abgebrochen, sodass für das aktuelle Bild kein Ereignis ausgelöst wurde, was die Leistung des Browsers erheblich optimierte.

Zusammenfassen

Damit ist dieser Artikel über drei Methoden zur Implementierung von Lazy Loading (lazyLoad) mit nativem JS abgeschlossen. Weitere relevante Inhalte zur Implementierung von Lazy Loading (lazyLoad) mit JS finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen!

Das könnte Sie auch interessieren:
  • JavaScript zum Implementieren des Vorladens und verzögerten Ladens von Bildern
  • Implementierung des Lazy Loading von JS-Bildern
  • Detaillierte Erklärung des Lazy-Loading-Prozesses von Bildern mit JS
  • So implementieren Sie das Lazy Loading von Routen in Vue.js
  • js, um einen Lazy-Loading-Effekt von Bildern zu erzielen
  • Detaillierte Erklärung zum Lay-Loading von JavaScript

<<:  Nginx: Ein Domänenname für den Zugriff auf mehrere Projekte – Methodenbeispiel

>>:  Lösung für die MySQL-Eingabeaufforderung „Beim Lesen der Kommunikationspakete ist eine Zeitüberschreitung aufgetreten“

Artikel empfehlen

So fügen Sie in Linux stapelweise Dateipräfixe hinzu

Sie müssen „gt_“ vor den Dateinamen aller TXT-Dat...

js, um einen einfachen Karusselleffekt zu erzielen

In diesem Artikel wird der spezifische Code von j...

So entwickeln Sie Uniapp mit vscode

Da ich immer vscode zur Entwicklung von Front-End...

Detailliertes Beispiel für die Verwendung einer asynchronen JS-Fetch-Anforderung

Inhaltsverzeichnis Asynchronität verstehen abrufe...

Detaillierte Erklärung der Gründe, warum MySQL-Verbindungen hängen bleiben

Inhaltsverzeichnis 1. Hintergrund Architektur Pro...

Teilen Sie 101 MySQL-Debugging- und Optimierungstipps

MySQL ist eine leistungsstarke Open-Source-Datenb...

Detaillierte Erklärung des JS-Speicherplatzes

Inhaltsverzeichnis Überblick 1. Stapeln und Aufhä...