React Academy · Les

Het probleem van grote lijsten renderen

Begrijp waarom het renderen van 10.000 DOM-nodes de prestaties sterk vermindert en hoe virtualisatie dit oplost.

Les 1 van 412 stappen

Het probleem van grote lijsten renderen is een gratis React Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject React Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus React Academy bevat in totaal 4 lessen.

10.000 li-elementen renderen

Stel dat u een array met tienduizend items doorloopt en voor elk item een li rendert. React maakt dan plichtsgetrouw tienduizend DOM-knooppunten, ook al passen er tegelijk maar een paar dozijn op het scherm.

De meeste van die knooppunten staan buiten beeld en zijn onzichtbaar, maar de browser moet ze allemaal aanmaken, indelen en bijhouden.

Browserkosten voor grote DOM-bomen

Grote DOM-bomen kosten de browser daadwerkelijk veel werk. De indeling, het opnieuw berekenen van stijlen en het geheugengebruik nemen allemaal toe met het aantal knooppunten, waardoor een enorme lijst de eerste render vertraagt en meer geheugen gebruikt.

Zelfs eenvoudige interacties kunnen haperen wanneer de engine tienduizenden knooppunten moet bijhouden en opnieuw moet indelen.

Afname van de scrollprestaties

Bij een enorme lijst merken gebruikers de problemen vooral tijdens het scrollen. De browser tekent het scherm opnieuw en berekent de indeling mogelijk opnieuw terwijl de inhoud verschuift. Bij te veel knooppunten daalt de beeldsnelheid onder het niveau van vloeiende weergave.

Het resultaat is schokkerig en vertraagd scrollen, waardoor de interface niet reageert, hoe snel de rest van de app ook is.

Het aantal knooppunten meten in DevTools

U kunt het probleem bevestigen in het geheugenpaneel van de browser-DevTools, dat het aantal DOM-knooppunten op de pagina weergeeft. Een lijst die duizenden knooppunten aanmaakt, valt hier duidelijk op.

Als u ziet hoe dat aantal snel oploopt wanneer u meer items rendert, hebt u concreet bewijs dat de DOM-grootte het knelpunt is.

Het concept van virtualisatie

Virtualisatie, ook wel venstering genoemd, rendert alleen de items die momenteel zichtbaar zijn, plus een kleine buffer, in plaats van de hele lijst. Terwijl u scrollt, worden items die in beeld komen aan de DOM toegevoegd en items die uit beeld verdwijnen verwijderd.

Daardoor blijft de actieve DOM klein, ongeacht hoeveel items de gegevens bevatten, en staat de DOM-grootte los van de grootte van de gegevensset.

Het zichtbare venster berekenen

Het zichtbare venster wordt afgeleid van de scrollpositie, de hoogte van de container en de hoogte van een item. Als u de hoogte van het weergavegebied deelt door de itemhoogte, weet u ongeveer hoeveel rijen erin passen; de scrollverschuiving geeft aan om welke rijen het gaat.

De bibliotheek gebruikt deze getallen om op elk moment precies te bepalen welk deel van de items moet worden gerenderd.

react-virtualized tegenover react-window tegenover TanStack Virtual

Verschillende bibliotheken implementeren venstering. react-virtualized biedt veel functies maar is groter, react-window is een kleinere, gerichte herschrijving door dezelfde auteur en TanStack Virtual is een moderne optie zonder ingebouwde gebruikersinterface.

Voor de meeste lijsten biedt react-window een uitstekende balans tussen eenvoud en prestaties. Daarom richt deze cursus zich daarop.

Wanneer virtualisatie nodig is

Virtualisatie levert voordeel op bij lange lijsten, grofweg enkele honderden rijen of meer, of wanneer rijen veel afbeeldingen en geneste componenten bevatten. In die gevallen vormt de DOM-grootte echt een probleem.

Oneindige feeds, grote gegevenstabellen en chatgeschiedenissen zijn typische situaties waarin venstering noodzakelijk en niet langer optioneel is.

Wanneer het de moeite niet waard is

Voor korte lijsten met enkele tientallen eenvoudige items voegt virtualisatie complexiteit toe zonder merkbaar voordeel. De overhead van absolute positionering en metingen kan zelfs per saldo nadelig zijn.

Gebruik venstering alleen voor echt grote gegevenssets; voor kleine gegevenssets is een gewone map eenvoudiger en snel genoeg.

De winst

Met venstering houdt een lijst met honderdduizend items alleen de paar zichtbare items in de DOM. Daardoor is de eerste render snel, blijft het geheugengebruik laag en verloopt het scrollen vloeiend.

U ruilt wat extra complexiteit bij het instellen in voor prestaties die niet langer afhangen van de hoeveelheid gegevens. Dat is de kernbelofte van virtualisatie.

Korte controle: wanneer virtualiseren

Bepaal wanneer virtualisatie de moeite waard is.

Samenvatting: het probleem van grote lijsten

Het renderen van duizenden DOM-knooppunten verhoogt de kosten voor de indeling, het geheugengebruik en schokkerig scrollen. U kunt dit bevestigen via het aantal knooppunten in DevTools. Virtualisatie rendert alleen het zichtbare venster plus een buffer, zodat de DOM klein blijft.

react-window is een gerichte, lichte keuze naast react-virtualized en TanStack Virtual. Gebruik het voor grote of zware lijsten en laat het achterwege voor korte, eenvoudige lijsten.

Gratis beginnen

Leer React met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
88
Lessen
324

Veelgestelde vragen

Is de les “Het probleem van grote lijsten renderen” gratis?

Ja — de volledige tekst van “Het probleem van grote lijsten renderen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus React Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus React Academy bevat in totaal 4 lessen.

Wat leer ik in “Het probleem van grote lijsten renderen”?

Begrijp waarom het renderen van 10.000 DOM-nodes de prestaties sterk vermindert en hoe virtualisatie dit oplost. Je oefent met React Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met React Academy te beginnen?

Ervaring vooraf is niet nodig. React Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Het probleem van grote lijsten renderen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over React Academy?

Ja. Elke les over React Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. Het probleem van grote lijsten renderen
  2. FixedSizeList: duizenden items renderen
  3. VariableSizeList: dynamische rijhoogten
  4. Virtualisatie combineren met data fetching
← Terug naar React Academy