Top 40 React JS-interviewvragen en -antwoorden (2026)

Bereid je je voor op een sollicitatiegesprek voor React JS? Het is tijd om te ontdekken wat je te wachten staat. React JS-interviewvragen helpt zowel uw conceptuele helderheid als uw sterke punten in de praktijk te onthullen.

React JS biedt enorme carrièremogelijkheden voor professionals met technische ervaring en domeinexpertise. Of je nu een starter of senior bent met 5 of 10 jaar professionele ervaring, analysevaardigheden en technische expertise zijn belangrijk. Deze vragen en antwoorden helpen teamleiders, managers en ontwikkelaars hun vaardigheden te verfijnen en succesvolle sollicitatiegesprekken te voeren.

Deze compilatie is gebaseerd op inzichten van meer dan 85 professionals, waaronder personeelsmanagers en technische leiders, en weerspiegelt de uiteenlopende verwachtingen in de sector en echte interviewpatronen van werkteams in verschillende domeinen.

React JS-interviewvragen en -antwoorden

Top React JS-interviewvragen en -antwoorden

1) Leg uit wat de virtuele DOM is en hoe afstemming werkt in React.

Antwoord:

De virtuele DOM is een in-memory representatie van de gebruikersinterface die React onderhoudt om wijzigingen in de gebruikersinterface efficiënt te berekenen. Wanneer de status of props muteren, rendert React een nieuwe virtuele DOM-boom en voert vervolgens een verschillen algoritme tegen de vorige boom om de minimale set van vereiste echte DOM-bewerkingen te ontdekken. Dit proces, genaamd verzoeningminimaliseert lay-out-verstoring en kostbare browser-reflows. React wijst toe toetsen elementen in lijsten om knooppunten over verschillende renders te matchen, en het gebruikt heuristiek (zoals het vergelijken van typen en sleutels) om te beslissen of knooppunten moeten worden bijgewerkt, opnieuw geordend of verwijderd. De voordelen zijn onder andere voorspelbare updates, een kleiner oppervlak voor bugs en betere prestaties in complexe gebruikersinterfaces.

Voorbeeld:

Een dynamische lijst met chatberichten weergeven: door gebruik te maken van stabiele key waarden (bericht-ID's) worden alleen nieuwe berichten aan de DOM toegevoegd, terwijl bestaande knooppunten onaangetast blijven, waardoor onnodige herrenderingen worden vermeden.

👉 Gratis PDF-download: React JS-interviewvragen en -antwoorden


2) Wat zijn de verschillende typen componentlevenscycli in React en hoe worden Hooks hierop afgestemd?

Antwoord:

React-componenten doorlopen de fasen van koppelen, bijwerken en ontkoppelen. In klassecomponenten worden levenscyclusmethoden zoals componentDidMount, shouldComponentUpdate, componentDidUpdateen componentWillUnmount bijwerkingen, renderingbeslissingen en opruiming beheren. In functionele componenten, haken gelijkwaardige mogelijkheden bieden: useEffect behandelt effecten na het renderen; opruimfuncties binnenin useEffect uitvoeren bij het loskoppelen of vóór het volgende effect; useMemo en useCallback controle memoisatie; en useRef behoudt veranderlijke referenties tussen renders. De voordelen van hooks zijn onder andere de mogelijkheid om samen te stellen, minder problemen met "this"-bindingen en eenvoudiger hergebruik van logica via aangepaste hooks. Het grootste nadeel is echter de noodzaak om de regels van hooks en afhankelijkheidsbeheer te leren.

Antwoord met voorbeelden:

  • Oplopend effect: useEffect(() => fetchData(), []).
  • Opruimen bij ontkoppelen: useEffect(() => { start(); return stop; }, []).

3) Hoe kiest u tussen client-side rendering (CSR), server-side rendering (SSR), static site generation (SSG) en incrementele statische regeneratie (ISR) voor een React-applicatie?

Antwoord:

De renderingstrategie moet worden bepaald door de eisen aan de gebruikerservaring, de actualiteit van de gegevens, SEO-behoeften, infrastructuurbeperkingen en de ontwikkelingssnelheid. CSR geschikt voor zeer interactieve apps achter authenticatie waarbij SEO secundair is. SSR biedt first paint met echte gegevens voor openbare pagina's, waardoor de Time to First Byte en SEO worden verbeterd, maar de serverkosten stijgen wel. SSG Berekent pagina's vooraf tijdens het bouwen voor uitstekende snelheid en caching wanneer gegevens niet vaak veranderen. ISR Werkt statische pagina's stapsgewijs bij op aanvraag en biedt zo een balans tussen actualiteit en prestaties. Factoren die hierbij een rol spelen zijn onder meer cacheerbaarheid, personalisatie, latentie voor wereldwijde doelgroepen en operationele complexiteit.

Tabel: Voordelen versus nadelen

Aanpak Voordelen Nadelen
CSR Eenvoudige hosting, rijke interactiviteit Langzamere eerste verflaag, zwakkere SEO
SSR Uitstekende SEO, nieuwe gegevens bij de eerste keer laden Hogere serverbelasting, complexiteit
SSG Snel, goedkoop, CDN-vriendelijk Verouderde inhoud tot herbouw
ISR Snel met gecontroleerde versheid Meer bewegende delen om te beheren

4) Welke strategie voor statusbeheer moet worden gebruikt: lokale status, Context, Redux of querybibliotheken?

Antwoord:

Kies de eenvoudigste gereedschap die de kenmerken van het probleem afhandelt. Component-lokale status via useState or useReducer is ideaal voor geïsoleerde UI-problemen. Context werkt voor voornamelijk leesbare, toepassingsbrede waarden (thema, landinstellingen, huidige gebruiker), maar is niet geoptimaliseerd voor updates met een hoge frequentie in grote bomen. Redux of vergelijkbare event-sourced stores zijn ideaal als u behoefte hebt aan voorspelbaarheid, debugging van tijdreizen, middleware en strikte unidirectionele gegevensstromen. Bibliotheken voor het ophalen van gegevens (bijvoorbeeld patronen in de stijl van React Query) beheren de levenscyclus van de serverstatus, zoals caching en deduplicatie.pingStrategieën voor het opnieuw ophalen van gegevens en synchronisatie – waardoor overbodige code wordt verminderd. Een pragmatische architectuur maakt vaak gebruik van lokale status + Context voor configuratie + een serverstatusbibliotheek, waarbij Redux gereserveerd is voor complexe workflows.

Voorbeeld:

Een dashboard gebruikt React Query voor API-caching, Context voor thema en useReducer in complexe widgets voor lokale gebeurtenisafhandeling.


5) Wat is het verschil tussen useEffect en useLayoutEffect, en wanneer is elk van toepassing?

Antwoord:

useEffect wordt uitgevoerd nadat de browser heeft geschilderd, waardoor het geschikt is voor niet-blokkerende taken zoals het ophalen van gegevens, abonnementen en loggen. useLayoutEffect wordt uitgevoerd synchroon na DOM-mutaties maar vóór verf, waardoor metingen en lay-outaanpassingen mogelijk zijn die zonder flikkering moeten plaatsvinden (bijvoorbeeld het lezen van elementgroottes en het synchroon opnieuw toepassen van stijlen). Het nadeel van useLayoutEffect is dat het de verf kan blokkeren en de responsiviteit kan schaden als het overmatig wordt gebruikt. Een goede regel is om te beginnen met useEffect voor bijwerkingen en reik naar useLayoutEffect alleen als u de lay-out moet meten of synchroon moet muteren om de visuele correctheid te garanderen.

Antwoord met voorbeelden:

  • useEffect: gebruikersprofiel ophalen na renderen.
  • useLayoutEffect: bepaal de grootte van een tooltip om deze te positioneren vóór het tekenen.

Snelle vergelijking

Kenmerk gebruikEffect gebruikLayoutEffect
Timing Na het schilderen Voor het schilderen
Gebruik geval Gegevens, abonnementen Metingen, synchrone lay-outoplossingen
Risico Kleine kras als het zwaar is Blokkeert verf als het zwaar is

6) Leg uit hoe sleutels werken in lijsten en wat de valkuilen zijn bij het gebruik van array-indices.

Antwoord:

Sleutels maken de afstemming van React mogelijk om lijstitems nauwkeurig te identificeren tussen renders. Stabiele, unieke sleutels stellen React in staat om items opnieuw te ordenen, in te voegen of te verwijderen met minimale DOM-verloop. array-indices Sleutels zijn problematisch wanneer items opnieuw geordend, ingevoegd of verwijderd kunnen worden, omdat React een eerdere status aan het verkeerde element kan koppelen, wat subtiele bugs kan veroorzaken (bijvoorbeeld onjuiste invoerwaarden of animaties). De beste praktijk is om een ​​onveranderlijke, domeinspecifieke identificatie te gebruiken, zoals een database-ID. Als de lijst echt statisch is en nooit opnieuw wordt geordend, zijn indices acceptabel, maar dit is eerder uitzondering dan regel.

Voorbeeld:

Een versleepbaar Kanban-bord moet kaart-ID's gebruiken en geen indexen, zodat de identiteit van de componenten behouden blijft tijdens het slepen en neerzetten.


7) Waar zijn memoisatietechnieken van toepassing in React, en wat zijn hun voor- en nadelen?

Antwoord:

Memoisatie vermindert onnodige berekeningen en opnieuw renderen door eerdere resultaten te hergebruiken wanneer de invoer niet is gewijzigd. In React, React.memo cachet componentuitvoer, useMemo cachet dure berekeningen, en useCallback Onthoudt functie-identiteiten die aan kinderen worden doorgegeven. De belangrijkste voordelen zijn prestatiestabiliteit en verminderd CPU-gebruik bij intensieve interactie. Nadelen zijn onder andere complexiteit, potentiële stale-cache bugs als afhankelijkheden onjuist zijn, en geheugenoverhead.

Tabel: Verschillende manieren om te onthouden

Type Doel Typische factoren om te overwegen
React.memo(Component) Sla opnieuw renderen over als de props ondiep-gelijk zijn Propvolatiliteit, kinderkosten
useMemo(fn, deps) Berekende waarden in de cache opslaan Kosten van rekenkracht versus geheugen
useCallback(fn, deps) Stabiele functie-identiteit Afhankelijkheidscorrectheid

Antwoord met voorbeelden:

Onthoud een gefilterde, gesorteerde dataset voor een raster met behulp van useMemoen wikkel celrenderercomponenten in met React.memo om re-renderstormen te voorkomen.


8) Geeft u de voorkeur aan gecontroleerde of ongecontroleerde componenten voor formulieren? Bespreek de voordelen, nadelen en soorten formulierstatussen.

Antwoord:

Gecontroleerde componenten bind invoer aan React-status via value en onChange, waardoor validatie, maskering en voorwaardelijke gebruikersinterface mogelijk zijn, gebaseerd op één bron van waarheid. De voordelen zijn voorspelbaarheid en eenvoudige integratie met andere statussen; nadelen zijn onder andere de kosten voor het opnieuw renderen bij elke toetsaanslag zonder optimalisatie. Ongecontroleerde componenten Vertrouw op de DOM als bron van waarheid met behulp van refs, wat zorgt voor lagere overhead en eenvoudigere bedrading voor basisformulieren, maar minder gecentraliseerde validatie. Voor complexe workflows is een hybride patroon gebruikelijk, met gecontroleerde invoer voor kritieke velden en ongecontroleerde invoer voor grote, tekstrijke gebieden.

Voorbeeld:

Een aanmeldformulier gebruikt gecontroleerde velden voor e-mail- en wachtwoordvalidatie, terwijl een tekstvak voor notities niet gecontroleerd is om de overhead van opnieuw renderen te beperken.


9) Wanneer zou je Context gebruiken en wanneer een aangepaste hook, en wat is het conceptuele verschil tussen beide?

Antwoord:

Context is een transportmechanisme voor waarden die veel componenten nodig hebben, waardoor propboren wordt vermeden. Het beheert de status niet zelf; het stelt deze simpelweg beschikbaar aan afstammelingen. A aangepaste haak Encapsuleert herbruikbare logica – die status, effecten en externe services combineert – en retourneert waarden en functies. Gebruik Context om gedeelde, grotendeels leesbare configuratie te bieden of om een ​​opslag bloot te leggen, en gebruik aangepaste hooks om het gedrag van de opslag te implementeren of om zaken zoals authenticatie, feature flags of data-ophaalbeleid te orkestreren. De twee zijn complementair: een gemeenschappelijk patroon is useAuth() als een aangepaste haak ondersteund door een AuthContext.

Antwoord met voorbeelden:

AuthProvider levert gebruiker en tokens via Context; useAuth behandelt de bijwerkingen van inloggen, vernieuwen en uitloggen.


10) Kunt u strategieën voor prestatie-afstemming voor grote React-applicaties schetsen, inclusief kenmerken van langzame renders en hotspots in de levenscyclus?

Antwoord:

Prestatie-afstemming begint met meten. Identificeer trage paden met behulp van de React DevTools Profiler en browserprestatiepanelen om reconciliatiehotspots en dure commits te lokaliseren. Tactieken omvatten: staatsgemeente (de staat dichtbij de consumenten houden), memoization (React.memo, useMemo, useCallback), lijstvirtualisatie voor lange lijsten, code splitsen met lazy loading om de initiële bundel te verkleinen, en debouncing of throttlen gebeurtenissen met een hoge frequentie. Gebruik voor servergebaseerde data caching met een querybibliotheek en maak gebruik van spanningsvriendelijk Patronen voor soepeler laden. Let op hotspots in de levenscyclus, zoals effecten die te vaak worden uitgevoerd vanwege te brede afhankelijkheidsarrays, of componenten die opnieuw worden weergegeven vanwege frequent veranderende contextwaarden.

Antwoord met voorbeelden:

Virtualiseer een tabel met 10,000 rijen met behulp van een windowing-bibliotheek; laad zware grafieken lui achter routegebaseerde codesplitsing om de initiële weergave te verbeteren.


11) Wat is het verschil tussen props en state in React?

Antwoord:

Beiden props en state hebben invloed op de manier waarop componenten worden weergegeven, maar hun doel en levenscyclus verschillen fundamenteel. rekwisieten (afkorting van eigenschappen) zijn onveranderlijke invoergegevens die van een ouder- naar een kindcomponent worden doorgegeven en die de configuratie of gegevens voor rendering definiëren. naar beneden in de unidirectionele gegevensstroom van React en mag nooit worden gewijzigd door het ontvangende onderdeel. Land, daarentegen, is veranderlijk en wordt intern door het component onderhouden. Het bepaalt dynamisch gedrag dat in de loop van de tijd verandert, zoals invoerwaarden in formulieren of het in- en uitschakelen van de zichtbaarheid.

Tabel met belangrijkste verschillen:

Factor rekwisieten Land
veranderlijkheid Onveranderlijk Veranderlijk
Eigendom Door ouder doorgegeven Eigendom van component
Bijwerkmethode: Ouderlijke herrenderingen useState or setState
Use Case Configuratie Dynamische UI-wijzigingen
Levenscyclus Bestaat tijdens renderen Blijft bestaan, activeert opnieuw renderen

Voorbeeld:

A <Button color="blue" /> gebruikt rekwisieten om de kleur te bepalen, terwijl een clicked boolean in de status schakelt visuele feedback in of uit.


12) Leg het componentarchitectuurpatroon in React uit en de verschillende manieren waarop componenten worden geclassificeerd.

Antwoord:

React-applicaties volgen een componentgebaseerde architectuur, waarbij de gebruikersinterface wordt opgedeeld in kleine, herbruikbare bouwstenen. Componenten kunnen worden gecategoriseerd op basis van hun doel en verantwoordelijkheid:

  1. Presentatie (domme) componenten – Focus op de gebruikersinterface, ontvang gegevens via props en beheer zelden de status.
  2. Container (slimme) componenten – Verwerken logica, halen gegevens op en beheren de status; ze geven presentatiecomponenten weer.
  3. Componenten van hogere orde (HOC's) – Functies die een component nemen en een verbeterde versie met aanvullend gedrag retourneren.
  4. Zuivere componenten – Optimaliseer de prestaties door props en status oppervlakkig te vergelijken.
  5. Functionele versus klassecomponenten – Functionele componenten (met hooks) krijgen nu de voorkeur vanwege de leesbaarheid en prestaties.

Voorbeeld:

A <UserProfile /> component kan presentatief zijn, gebruikersinformatie ontvangen, terwijl <UserProfileContainer /> haalt gegevens op en beheert de levenscyclus ervan.


13) Hoe gaat React om met foutgrenzen en waarom zijn ze belangrijk?

Antwoord:

Foutgrenzen zijn speciale React-componenten die JavaScriptfouten overal in hun onderliggende componentboom tijdens rendering, levenscyclusmethoden of constructors. Ze voorkomen dat een hele app crasht door fouten te isoleren tot specifieke subbomen. Je kunt er een implementeren met componentDidCatch(error, info) en static getDerivedStateFromError() in een klassecomponent.

Voordelen:

  • Behoud de stabiliteit van de gebruikersinterface door fallback-gebruikersinterfaces weer te geven.
  • Registreer en registreer fouten voor analyses.
  • Voorkom trapsgewijze ontkoppelingen.

Voorbeeld:

class ErrorBoundary extends React.Component {
  state = { hasError: false };
  static getDerivedStateFromError() { return { hasError: true }; }
  render() { return this.state.hasError ? <h2>Something went wrong.</h2> : this.props.children; }
}

14) Wat zijn React-fragmenten en hoe verschillen ze van wrappers? elementen?

Antwoord:

Reageren Fragmenten (<></>) kunt u meerdere elementen groeperen zonder extra knooppunten aan de DOM toe te voegen. Dit is essentieel voor een overzichtelijkere structuur, vooral in lijsten, tabellen en semantische HTML, waar extra wrappers lay-out- of toegankelijkheidsproblemen kunnen veroorzaken. In tegenstelling tot wrappers <div>Fragmenten worden niet naar de DOM gerenderd en bieden daarom prestatie- en semantische voordelen.

Voorbeeld:

return (
  <>
    <h1>Title</h1>
    <p>Description</p>
  </>
);

Verschiltabel:

Factor fragment <div> Wikkel
DOM-uitvoer Geen Voegt extra knooppunt toe
Use Case Structurele groepping Styling of lay-out
Prestaties Betere Lichte overhead

15) Welke React Hook zou je gebruiken voor prestatie-optimalisatie en waarom?

Antwoord:

Prestatiegevoelige React-componenten vertrouwen vaak op memoisatiehaken en trage voortgang om overbodig werk te minimaliseren. Veelvoorkomende haken zijn onder andere:

  • useMemo → Slaat rekenintensieve resultaten op in de cache.
  • useCallback → Voorkomt onnodige kindrenderingen als gevolg van wijzigingen in de identiteit van functies.
  • useTransition → Stelt niet-dringende updates uit voor een soepelere gebruikersinterface.
  • useDeferredValue → Stelt zware berekeningen uit tot na directe interacties.

Voorbeeld:

Een groot gegevensraster met behulp van useMemo voor gefilterde resultaten kan het CPU-verbruik met 50% of meer worden verminderd.

Voordelen:

  • Vermindert verspilling van renders.
  • Zorgt ervoor dat de gebruikersinterface responsief blijft onder belasting.

Nadeel:

  • Vereist afhankelijkheidsprecisie; bij onjuist beheer kunnen verouderde cachebugs ontstaan.

16) Wat zijn React Portals en wat zijn hun voordelen?

Antwoord:

Portals React-componenten toestaan ​​om onderliggende elementen weer te geven in een DOM-knooppunt buiten hun bovenliggende hiërarchie, meestal voor modals, tooltips of dropdowns die visueel moeten "ontsnappen" aan overflow- of stapelcontexten. Geïmplementeerd met ReactDOM.createPortal(child, container), behouden ze de consistentie van event bubbling, zodat event handlers werken alsof het element binnen de oorspronkelijke hiërarchie is gebleven.

Voordelentabel:

Voordeel Beschrijving
Structurele onafhankelijkheid Render buiten de bovenliggende boom
CSS/stapelbeheer vermijden overflow: hidden of z-index problemen
Gebeurtenisvoortplanting De synthetische gebeurtenissen van React bubbelen nog steeds correct
Herbruikbaarheid Ideaal voor wereldwijde overlays

Voorbeeld:

createPortal(<ModalContent />, document.getElementById('modal-root'));

17) Leg uit hoe React Router de navigatie en de status tussen pagina's beheert.

Antwoord:

React Router is een declaratieve routingbibliotheek die de gebruikersinterface synchroniseert met de browser. URL. Het maakt gebruik van de geschiedenis API om de sessiegeschiedenis te manipuleren zonder de volledige pagina opnieuw te laden. Kernconcepten omvatten routes, Linksen Outlet voor geneste routering. De bibliotheek ondersteunt dynamische routes, URL parametersen navigatiehaken (useNavigate, useParams, useLocation). React Router v6 introduceerde een vereenvoudigde syntaxis en data-API's voor lader en actie functies, verbetering van SSR-integratie en statusbeheer.

Voorbeeld:

<Route path="/user/:id" element={<UserProfile />} />

Voordelen:

  • Maakt navigatie op één pagina mogelijk.
  • Behoudt de scrollpositie en geschiedenis.
  • Integreert naadloos met lazy loading voor betere prestaties.

18) Wat zijn de verschillende manieren om met bijwerkingen in React-toepassingen om te gaan?

Antwoord:

Bijwerkingen zijn acties die van invloed zijn op iets buiten het bereik van een component (API-aanroepen, DOM-manipulatie, abonnementen). De belangrijkste tools zijn:

  1. useEffect voor client-side effecten na het renderen.
  2. Gebeurtenis-handlers voor gebruikersgestuurde effecten.
  3. Aangepaste haken om effectlogica opnieuw te gebruiken (bijvoorbeeld useFetch).
  4. Middleware (zoals Redux Saga of Thunk) voor complexe asynchrone orkestratie.
  5. React Query of SWR voor het automatisch beheren van de serverstatus en het opnieuw ophalen van levenscycli.

Voorbeeld:

A useEffect Haalt gegevens één keer op bij het koppelen:

useEffect(() => { fetchData(); }, []);

Voordelen:

Vereenvoudigd async-beheer, betere encapsulatie en duidelijker beheer van de levenscyclus.


19) Is React een framework of een bibliotheek? Bespreek de factoren die het verschil bepalen.

Antwoord:

React is officieel een , geen volwaardig raamwerk. Het richt zich uitsluitend op de weergavelaag, waarbij rendering, status en componentabs worden geleverdtracties zonder routing, data-ophaling of buildstructuur af te dwingen.

Vergelijkingstabel:

Factor Bibliotheek (React) Raamwerk (Angular, Vue)
strekking Weergaveweergave Volledige MVC-architectuur
eigenzinnig Laag Hoge
Controleer: Ontwikkelaargestuurd Framework-gedreven
Flexibiliteit Hoge Beperkt door conventies
Leercurve Gemiddeld Hoger vanwege complexiteit

Het ecosysteem van React (Redux, Router, Query, Next.js) vormt in feite een 'meta-framework' dat modulaire opbouwmogelijkheden biedt waarmee ontwikkelaars hun eigen architectuur kunnen bouwen.


20) Wanneer moet je React.lazy en Suspense gebruiken en wat zijn de voordelen ervan?

Antwoord:

React.lazy maakt code splitsen door componenten alleen dynamisch te laden wanneer dat nodig is, terwijl Suspense Biedt een fallback-gebruikersinterface totdat het onderdeel klaar is. Deze combinatie verbetert de prestaties bij het eerste laden en de door de gebruiker waargenomen responsiviteit.

Voorbeeld:

const Chart = React.lazy(() => import('./Chart'));
<Suspense fallback={<Loader />}>
  <Chart />
</Suspense>

Voordelentabel:

Voordeel Uitleg
Prestaties Laadt code op aanvraag
Gebruikerservaring Graceful loading fallback
Pakketgrootte Kleinere initiële bundel
Eenvoud Native React API, minimale installatie

Praktische tips:

  • Wikkel meerdere luie componenten in één Suspense-grens.
  • Gebruik zinvolle terugvalindicatoren voor toegankelijkheid.

21) Leg uit wat React Server Components (RSC's) zijn en wat hun voordelen zijn.

Antwoord:

React Server Components (RSC's) zijn een belangrijke innovatie die is geïntroduceerd om de prestaties en de ervaring van ontwikkelaars te verbeteren door componenten in staat te stellen renderen op de server zonder hun JavaScript naar de klantZe worden volledig op de server uitgevoerd, halen gegevens op, lezen uit databases of voeren I/O-bewerkingen op een veilige manier uit voordat ze de geserialiseerde uitvoer naar de client streamen.

Voordelen:

  • Kleinere bundelgrootte — Geen client-JS voor logica alleen voor de server.
  • Verbeterde prestatie — Server-side data-ophaling vermindert watervallen.
  • Security — Gevoelige code bereikt de browser nooit.
  • Betere caching — Servercomponenten zijn cachebaar aan de edge.

Voorbeeld:

A <ProductList /> servercomponent kan gegevens rechtstreeks uit een database halen en de resultaten doorgeven aan een <ProductCard /> cliëntcomponent.


22) Wat is het verschil tussen React-hydratatie en reconciliatie?

Antwoord:

Hoewel beide termen inhouden dat React de gebruikersinterface bijwerkt, is het doel ervan verschillend:

  • Verzoening is het proces waarbij de virtuele DOM-boom wordt vergeleken met de vorige versie om de minimale set DOM-updates te bepalen.
  • Hydratatieis daarentegen het proces van het koppelen van React's event listeners en interne structuren aan server-gerenderde HTML aan de clientzijde, door statische markup om te zetten in een volledig interactieve app.

Vergelijkingstabel:

Factor Verzoening Hydratatie
Trigger Client opnieuw renderen Eerste pagina laden (SSR)
Doel DOM efficiënt bijwerken Maak SSR HTML interactief
strekking Virtuele DOM-differentie Gebeurtenisbinding + statusherkoppeling
Frequentie Meerdere keren Eenmaal na SSR-render

Voorbeeld:

Nadat een Next.js-app vooraf gerenderde HTML verzendt, React hydrateert Het zorgt ervoor dat componenten reageren op gebeurtenissen zonder alles opnieuw te renderen.


23) Hoe verbetert Concurrent Rendering de gebruikerservaring in React 18+?

Antwoord:

Met gelijktijdige rendering kan React renderingwerk onderbreken, pauzeren of hervatten op basis van de prioriteit van de gebruiker. Dit voorkomt dat de gebruikersinterface vastloopt tijdens zware berekeningen of herrenderingen. Functies zoals useTransition en useDeferredValue Maak gebruik van dit vermogen om te scheiden dringende updates (zoals ty)ping) van niet-dringend (zoals filteren).

Voordelen:

  • Soepele, responsieve interacties.
  • Time-slicing om te voorkomen dat de hoofdthread wordt geblokkeerd.
  • Voorspelbare prioritering voor een betere UX.

Voorbeeld:

const [isPending, startTransition] = useTransition();
startTransition(() => setFilteredList(filter(items, term)));

Hier, bedanktping Het blijft soepel, zelfs bij het filteren van grote datasets, omdat React niet-urgente updates gelijktijdig inplant.


24) Wat zijn de verschillende manieren om testen uit te voeren in React-applicaties?

Antwoord:

Reactietesten kunnen worden ingedeeld in: eenheid, integratieen eind tot eind levels.

Testmethodentabel:

Type Gereedschap Doel
Eenheid er is Test geïsoleerde functies/componenten
Integratie Reageer testbibliotheek Test UI-interacties en statuswijzigingen
E2E Cypress / Toneelschrijver Test gebruikersstromen in echte browsers

Praktische tips:

  • Verkiezen Reageer testbibliotheek over Enzyme (modern, DOM-georiënteerd).
  • Mock API's met behulp van msw (Nep-servicemedewerker).
  • Vermijd het testen van implementatiedetails en concentreer u op gedrag.

Voorbeeld:

test('renders user name', () => {
  render(<User name="Alice" />);
  expect(screen.getByText(/Alice/)).toBeInTheDocument();
});

25) Welke buildtools en bundlers worden het meest gebruikt met React en wat zijn de verschillen?

Antwoord:

React kan worden geïntegreerd met verschillende bundlers en compilers, die elk zijn geoptimaliseerd voor verschillende use cases.

Vergelijkingstabel:

Gereedschap Kenmerken Voordelen Nadelen
webpack Zeer configureerbaar Volwassen, plugin-rijk Complexe opzet
schroef ESM-gebaseerde, razendsnelle dev-server Instant HMR, moderne syntaxis Beperkte ondersteuning voor oudere plug-ins
Pakket Nul-configuratie Automatische optimalisatie Less flexibel ingesteld
esbouwen Go-gebaseerde compiler Extreem snel Minder ecosysteem-plugins

Voorbeeld:

Moderne projecten maken vaak gebruik van schroef voor ontwikkelingssnelheid en esbouwen in CI/CD-pipelines voor efficiënte productiebuilds.


26) Hoe breidt Next.js de mogelijkheden van React uit?

Antwoord:

Next.js is een React-framework Biedt eigenzinnige architectuur voor routing, SSR en statische generatie. Het introduceert hybride renderingmodellen, API-routes en edge-ready implementatiefuncties.

Voordelen:

  • Ingebouwd SSR/SSG/ISR Ondersteunen.
  • App-router met React Server-componenten.
  • Beeldoptimalisatie en middleware voor prestaties en veiligheid.
  • Eenvoudige API-routes voor serverloze functies.

Voorbeeld:

app/page.js voor SSR-gerenderde pagina's; app/api/route.js voor server-eindpunten.

SamenvattendNext.js maakt React-apps voor productie mogelijk met minimale configuratie.


27) Wat zijn enkele veelvoorkomende prestatievalkuilen in React en hoe kunt u deze vermijden?

Antwoord:

Veelvoorkomende prestatieproblemen van React zijn:

  1. Onnodige herrenderingen — Repareer met behulp van React.memo of het splitsen van componenten.
  2. Inline object/array creatie - Gebruik useMemo voor stabiele referenties.
  3. Grote lijsten — Implementeer windowing (react-window, react-virtualized).
  4. Zware berekeningen — Memoiseren of uitbesteden aan webwerkers.
  5. Overmatig gebruik van context — Regelmatige updates verspreiden zich diep; geven de voorkeur aan afgeleide toestand.

Voorbeeld:

Als je slaagt { a: 1 } Inline aan een gememoriseerd component, wordt het bij elke bovenliggende render opnieuw gerenderd. Dit kan worden opgelost door het object te memoriseren.

Prestatietiptabel:

Issue Optimalisatietechniek
Opnieuw renderen React.memo, useCallback
Dure berekeningen useMemo, Webwerkers
Grote datasets virtualisatie
Regelmatige contextupdates Lokaliseer de status

28) Leg het verschil uit tussen useReducer en useState.

Antwoord:

Beide hooks beheren de status, maar ze verschillen in complexiteit en controle.

  • useState is ideaal voor eenvoudige, geïsoleerde toestandsovergangen.
  • useReducer centraliseert complexe toestandslogica in een reductiefunctiegebruik dispatch acties voor voorspelbare updates.

Vergelijkingstabel:

Factor gebruikStatus gebruikReducer
Syntaxis [value, setValue] [state, dispatch]
Ingewikkeldheid Eenvoudig Matig tot complex
Use Case Onafhankelijke staten Verwante of geneste toestanden
Debugging Less breedsprakig Gemakkelijker via geregistreerde acties
Voorbeeld Formulier wisselt Formuliervalidatie of meerstapsformulieren

Voorbeeld:

const [state, dispatch] = useReducer(reducer, { count: 0 });
dispatch({ type: 'increment' });

29) Hoe kun je de toegankelijkheid (a11y) in React-applicaties verbeteren?

Antwoord:

Toegankelijkheid zorgt ervoor dat alle gebruikers, inclusief gebruikers met een beperking, je app effectief kunnen gebruiken. React vergemakkelijkt de toegankelijkheid via semantische markup en ARIA-attributen.

Praktische tips:

  • Gebruik semantische HTML (<button> vs <div onClick>).
  • Beheer de focus met behulp van ref en tabIndex.
  • Gebruik ARIA-rollen voor dynamische componenten.
  • Zorg voor kleurcontrast en tekstalternatieven voor afbeeldingen.
  • Maak gebruik van hulpmiddelen zoals eslint-plugin-jsx-a11y en as-kern voor audits.

Voorbeeld:

<button aria-label="Close dialog" onClick={closeModal}>×</button>

Voordelen:

  • Groter publiek bereiken.
  • SEO-verbetering.
  • Voldoen aan WCAG-normen.

30) Kunt u beschrijven wat het verschil is tussen code splitsen en lazy loading en wanneer u welk type moet gebruiken?

Antwoord:

Beide technieken optimaliseren de bundelgrootte en de laadprestaties, maar verschillen in uitvoeringstiming.

  • Code splitsen verdeelt grote bundels in kleinere stukken die onafhankelijk van elkaar geladen kunnen worden.
  • Trage voortgang stelt het laden van die brokken uit totdat ze nodig zijn.

Vergelijkingstabel:

Factor Code Splitsen Lazy laden
Definitie Verdeelt code in stukken Laadt stukken op aanvraag
Gereedschap Webpack, Vite React.lazy, dynamisch import()
Doel Optimaliseer de bundelgrootte Verbeter de runtime-prestaties
Uitvoering Bouwtijd Runtime

Voorbeeld:

const Settings = React.lazy(() => import('./Settings'));

Als u deze technieken samen gebruikt, wordt de Time to Interactive verkort en wordt de waargenomen snelheid van grote apps verbeterd.


31) Leg het concept van Render Props uit en hoe het verschilt van Higher-Order Components (HOC's).

Antwoord:

Render-rekwisieten is een patroon in React waarbij een component een functioneren als steunpilaar die aangeeft wat er gerenderd moet worden. Dit maakt het mogelijk om componentlogica te delen tussen meerdere componenten zonder duplicatie.

HOC's daarentegen, wikkel een component en retourneert een verbeterde versie met geïnjecteerde props of gedragingen.

Vergelijkingstabel:

Factor Render-rekwisieten HOC
Implementatie Functie als kind Functieomwikkelingping bestanddeel
Samenstelling: Inline-bediening Declaratieve wrapperping
leesbaarheid Vaak duidelijker Kan een wikkelhel veroorzaken
Use Case Dynamische weergavelogica Dwarsdoorsnijdende zorgen

Voorbeeld:

<DataProvider render={data => <UserList users={data} />} />

Render Props bieden meer flexibiliteit en voorkomen naamconflicten die vaak voorkomen in HOC's.


32) Wat zijn de verschillende soorten aangepaste haken en wat zijn hun voordelen?

Antwoord:

Aangepaste hooks kapselen herbruikbare logica in die status, neveneffecten en hulpprogramma's combineert. Ze verbeteren de herbruikbaarheid van code, de scheiding van aandachtspunten en de testbaarheid.

Typen en voorbeelden:

  1. Staatsbeheerhaken - useToggle, useForm.
  2. Gegevensophaal-hooks - useFetch, useQuery.
  3. UI/UX-hooks - useWindowSize, useDarkMode.
  4. Integratiehaken - useLocalStorage, useMediaQuery.
  5. Prestatiehaken - useDebounce, useThrottle.

Voordelen:

  • Gecentraliseerd hergebruik van logica.
  • Schonere componenten.
  • Onafhankelijke tests.

Voorbeeld:

function useLocalStorage(key, initial) {
  const [value, setValue] = useState(() => JSON.parse(localStorage.getItem(key)) || initial);
  useEffect(() => localStorage.setItem(key, JSON.stringify(value)), [value]);
  return [value, setValue];
}

33) Hoe ga je om met geheugenlekken in React-applicaties?

Antwoord:

Geheugenlekken treden op wanneer niet-gemonteerde componenten nog steeds verwijzingen naar resources of abonnementen bevatten. Ze verslechteren de prestaties en veroorzaken onvoorspelbaar gedrag.

Preventietechnieken:

  1. Opruimeffecten in useEffect: useEffect(() => { const id = setInterval(logData, 1000); return () => clearInterval(id); }, []);
  2. Asynchrone oproepen afbreken gebruik AbortController.
  3. Vermijd het bewaren van oude sluitingen verwijzend naar oude rekwisieten/staat.
  4. Afmelden voor evenementen of sockets bij het loskoppelen.
  5. Gebruik React Profiler om langzame geheugengroei te detecteren.

Voorbeeld:

Koppel in een chat-app altijd socketlisteners los wanneer een gebruiker de chatroom verlaat.


34) Wat zijn de beste werkwijzen voor het beheren van formulieren in grote React-applicaties?

Antwoord:

Voor het beheren van formulieren in React-apps op ondernemingsniveau is een balans nodig tussen controle, prestaties en onderhoudbaarheid.

Praktische tips:

  • Gebruik bibliotheken zoals vorm, Reageer Hook Formof Uiteindelijke vorm voor validatie en veldregistratie.
  • Groepeer gerelateerde velden met behulp van geneste componenten of contexten.
  • Toepassen schemavalidatie (Ja, Zod) voor consistentie.
  • Debounce zware validaties of API-controles.
  • Houd de formulierstatus gelokaliseerd, tenzij deze wereldwijd nodig is.

Voorbeeld:

React Hook Form minimaliseert opnieuw renderen door de invoerstatus te isoleren.

const { register, handleSubmit } = useForm(); 
<input {...register('email', { required: true })} />

35) Welke ontwerppatronen zijn het meest bruikbaar bij React-ontwikkeling en wat zijn hun kenmerken?

Antwoord:

React leent zich uitstekend voor diverse softwareontwerppatronen voor een onderhoudbare en schaalbare UI-architectuur.

Patronen Beschrijving Voorbeeld
Container-presentator Logica (container) scheiden van gebruikersinterface (presentator) DataContainer → UI-component
Gecontroleerd-Ongecontroleerd Formuliergegevens beheren via status versus DOM Formik versus ruwe inputs
Samengestelde componenten Ouders bepalen de samenstelling van hun kind <Tabs><Tab /></Tabs>
Providerpatroon Status delen via Context ThemaProvider
Haakpatroon Hergebruik stateful logica useAuth, useFetch

Voorbeeld:

A Tabs component stelt context bloot zodat <Tab> kinderen registreren zichzelf automatisch — een schone toepassing van de Samengestelde component patroon.


36) Wat zijn de belangrijkste verschillen tussen React 18 en React 19?

Antwoord:

React 19 bouwt voort op het gelijktijdige fundament van React 18 met aanzienlijke nieuwe mogelijkheden.

Kenmerk Reageer 18 Reageer 19
Gelijktijdig renderen Geïntroduceerd Verbeterd met betere spanning
Servercomponenten Experimenteel Gestabiliseerd en geïntegreerd
Acties API Niet beschikbaar Nieuwe standaard voor het afhandelen van formulieracties
Activa laden Handleiding Automatisch laden van bronnen
Verbeterde foutafhandeling Basic Granulair met grenshaken

Belangrijkste voordelen:

React 19 richt zich op eenvoudigere datamutaties, ingebouwde formulieractiesen verbeterde asynchrone controlewaardoor SSR en progressieve hydratatie soepeler verlopen.


37) Hoe werkt Micro-Frontend? ArchiHoe integreert Tecture met React? Wat zijn de voordelen?

Antwoord:

Micro-frontends splitsen een grote webapp op in onafhankelijke, inzetbare front-endmodules. In een React-ecosysteem is elke micro-frontend een zelfstandige app die kan worden geïntegreerd via Module Federatie, iframesof aangepaste runtime-laders.

Voordelen:

  • Onafhankelijke implementatie en schaalbaarheid.
  • Teamautonomie over verschillende technologiestacks heen.
  • Sneller pijpleidingen bouwen.

Voorbeeld:

gebruik Federatie van Webpack-moduleskunnen teams React-componenten dynamisch in apps beschikbaar stellen:

exposes: { './NavBar': './src/NavBar' }

Nadelen:

  • Gedeelde complexiteit van staatsbeheer.
  • Prestatieoverhead van geïsoleerde bundels.

38) Welke factoren houdt u in gedachten bij het opschalen van een React-applicatie in productie?

Antwoord:

Het schalen van React-applicaties brengt technische, architectonische en operationele overwegingen met zich mee.

Sleutelfactoren:

  1. Code structuur — monorepos (Nx/Turborepo) gebruiken voor modulaire codedeling.
  2. Staatsbeheer — segmenteer lokale vs globale vs serverstatussen.
  3. Prestaties — lazy loading, memoisatie, CDN-caching.
  4. Monitoren — Gebruik Sentry, Datadog of LogRocket voor fouten en statistieken.
  5. Testen en CI/CD — geautomatiseerde pijplijnen en visuele regressietests.

Voorbeeld:

Een groot e-commerceplatform schaalt React-apps met Next.js voor SSR, Redux Toolkit voor voorspelbare status en micro-frontends voor geïsoleerde verticals.


39) Hoe test je React-componenten die asynchroon gedrag gebruiken?

Antwoord:

Voor het testen van asynchrone React-componenten is synchronisatie tussen de testrunner en de statusupdates van de componenten vereist.

Praktische tips:

  • Gebruik waitFor or findBy* query's in de React-testbibliotheek.
  • Mock fetch calls of API's met behulp van msw.
  • Verkiezen nep-timers (jest.useFakeTimers()) voor time-out-gebaseerde effecten.

Voorbeeld:

test('loads and displays data', async () => {
  render(<UserList />);
  expect(await screen.findByText('Alice')).toBeInTheDocument();
});

Dit zorgt ervoor dat de test wacht op de asynchrone updates van React voordat er beweringen worden gedaan.


40) Leg uit hoe je een grootschalige, onderhoudbare React-projectstructuur zou ontwerpen.

Antwoord:

Een schaalbaar React-project moet een evenwicht vinden tussen modulariteit, duidelijkheid en samenwerking binnen teams.

Aanbevolen mapstructuur:

src/
 ├── components/         # Reusable UI elements
 ├── features/           # Feature-specific modules
 ├── hooks/              # Custom reusable hooks
 ├── context/            # Global providers
 ├── pages/              # Route-level views
 ├── services/           # API and utilities
 ├── assets/             # Static resources
 ├── tests/              # Unit & integration tests
 └── index.js

Praktische tips:

  • Gebruik absolute imports met padaliassen.
  • Zorg voor strikte linting (ESLint + Prettier).
  • Gebruik TypeScript voor typeveiligheid.
  • Handhaaf componentgrenzen met atomair ontwerp of kenmerkgebaseerde slicing.

Voorbeeld:

In een realistische situatie zou een 'Gebruiker'-functie het volgende kunnen omvatten: UserSlice.js, UserAPI.js, UserCard.jsxen User.test.js, allemaal binnen src/features/user/.


🔍 Top React.js-interviewvragen met realistische scenario's en strategische antwoorden

1) Wat zijn de belangrijkste verschillen tussen functionele en klassecomponenten in React.js?

Verwacht van kandidaat: De interviewer wil uw begrip van de React-componentarchitectuur en moderne best practices testen.

Voorbeeld antwoord:

“Functionele componenten zijn eenvoudiger en vertrouwen op hooks voor het beheren van status- en levenscyclusmethoden, terwijl klassecomponenten this en levenscyclusmethoden zoals componentDidMountFunctionele componenten hebben tegenwoordig over het algemeen de voorkeur omdat ze schonere code bevorderen, gemakkelijker te testen zijn en beter presteren dankzij optimalisaties in het renderingproces van React.”


2) Kunt u uitleggen hoe de Virtual DOM werkt in React?

Verwacht van kandidaat: De interviewer wil graag weten in hoeverre u de belangrijkste prestatiemechanismen van React beheerst.

Voorbeeld antwoord:

De virtuele DOM is een in-memory weergave van de echte DOM. Wanneer de status van een component verandert, werkt React eerst de virtuele DOM bij, vergelijkt deze met de vorige versie met behulp van een proces genaamd 'diffing' en werkt vervolgens alleen de delen van de echte DOM bij die zijn gewijzigd. Deze aanpak verbetert de prestaties door directe DOM-manipulatie te minimaliseren.


3) Hoe beheer je de status van een grootschalige React-applicatie?

Verwacht van kandidaat: De interviewer wil graag meer weten over uw ervaringen met technieken en hulpmiddelen voor staatsbeheer.

Voorbeeld antwoord:

In grote applicaties gebruik ik meestal gecentraliseerde bibliotheken voor statusbeheer, zoals Redux of Zustand. Redux biedt een voorspelbare gegevensstroom en maakt debuggen eenvoudiger dankzij time-travel debugging tools. Voor eenvoudigere applicaties gebruik ik liever de Context API en hooks om onnodige complexiteit te vermijden.


4) Beschrijf een voorbeeld waarin u de prestaties van React hebt geoptimaliseerd.

Verwacht van kandidaat: De interviewer wil graag uw praktische ervaring met prestatieoptimalisatie begrijpen.

Voorbeeld antwoord:

"In mijn vorige functie werd onze applicatie overmatig opnieuw gerenderd vanwege onnodige statuswijzigingen. Ik gebruikte React.memo en useCallback hook om onnodige herrenderingen te voorkomen. Ik analyseerde ook de prestaties met de React Profiler en identificeerde componenten die memorisatie nodig hadden, wat de rendertijd met bijna 30% verkortte."


5) Hoe ga je om met bijwerkingen in React?

Verwacht van kandidaat: De interviewer wil graag uw begrip van hooks en lifecycle management beoordelen.

Voorbeeld antwoord:

“Ik behandel bijwerkingen zoals API-aanroepen of DOM-manipulaties met behulp van de useEffect hook. Met de hook kan ik afhankelijkheden specificeren, zodat het effect alleen wordt uitgevoerd wanneer die afhankelijkheden veranderen. Dit helpt om voorspelbaar gedrag te behouden en oneindige lussen te voorkomen.”


6) Vertel eens over een lastige bug die je tegenkwam in een React-project en hoe je die hebt opgelost.

Verwacht van kandidaat: De interviewer wil uw probleemoplossende en debugvaardigheden beoordelen.

Voorbeeld antwoord:

“In een vorige functie stuitte ik op een bug waarbij statusupdates niet in de gebruikersinterface werden weergegeven. Na onderzoek kwam ik erachter dat het probleem werd veroorzaakt door het direct muteren van het statusobject in plaats van het aanmaken van een nieuwe kopie. Ik heb de code gerefactored om onveranderlijke updates te gebruiken, wat het probleem oploste en de dataconsistentie verbeterde.”


7) Hoe ga je om met formuliervalidatie in React-applicaties?

Verwacht van kandidaat: De interviewer wil weten of u begrijpt hoe u gebruikersinvoervalidatie kunt implementeren.

Voorbeeld antwoord:

"Ik gebruik doorgaans gecontroleerde componenten voor het beheer van formulierinvoer, gecombineerd met bibliotheken zoals Formik of React Hook Form voor validatie. Deze tools vereenvoudigen het verwerken van fouten, het beheren van de formulierstatus en de integratie met externe validatiebibliotheken zoals Yup."


8) Beschrijf een situatie waarin je moest samenwerken met backend-ontwikkelaars tijdens het werken aan een React-project.

Verwacht van kandidaat: De interviewer wil uw teamwerk- en communicatievaardigheden beoordelen.

Voorbeeld antwoord:

In mijn laatste functie werkte ik nauw samen met backend-ontwikkelaars om REST API's voor een dashboardapplicatie te ontwerpen. We spraken af ​​over dataformaten en eindpunten in de vroege ontwikkelingsfases. Ik heb ook mock-responses gemaakt om de front-endontwikkeling voort te zetten terwijl de back-end werd gebouwd, om zo een soepele integratie later te garanderen.


9) Hoe zorgt u ervoor dat uw React-componenten herbruikbaar en onderhoudbaar zijn?

Verwacht van kandidaat: De interviewer wil meer weten over uw aanpak van componentontwerp en schaalbaarheid.

Voorbeeld antwoord:

Ik volg het principe van het bouwen van kleine, gerichte componenten die één verantwoordelijkheid dragen. Ik maak ook gebruik van props voor flexibiliteit en blijf modulair stylen met CSS-in-JS of styled-componenten. Dit zorgt ervoor dat componenten gemakkelijk hergebruikt en onderhouden kunnen worden gedurende het project.


10) Hoe blijf je op de hoogte van de trends en best practices van React.js?

Verwacht van kandidaat: De interviewer wil uw toewijding aan voortdurend leren evalueren.

Voorbeeld antwoord:

Ik blijf op de hoogte door de officiële documentatie en communityblogs van React te volgen. Ik bekijk ook presentaties van React-conferenties zoals React Conf en luister naar podcasts zoals 'React Podcast'. Deze bronnen helpen me op de hoogte te blijven van nieuwe functies zoals gelijktijdige rendering en servercomponenten.

Vat dit bericht samen met: