Topp 40 intervjufrågor och svar för React JS (2026)

Förbereder du dig för en intervju i React JS? Det är dags att utforska vad som väntar dig. Förståelse Intervjufrågor om React JS hjälper till att avslöja både din konceptuella tydlighet och dina styrkor i den verkliga implementeringen.

React JS erbjuder enorma karriärmöjligheter för yrkesverksamma med teknisk erfarenhet och domänexpertis. Oavsett om du är nyutexaminerad eller senior med 5 eller 10 års yrkeserfarenhet, är det viktigt att analysera färdigheter och teknisk expertis. Dessa frågor och svar hjälper teamledare, chefer och utvecklare att förfina sina färdigheter och klara toppintervjuer.

Baserat på insikter från över 85 yrkesverksamma, inklusive rekryteringschefer och tekniska ledare, återspeglar denna sammanställning olika branschförväntningar och verkliga intervjumönster som samlats in från arbetsteam inom olika områden.

Intervjufrågor och svar för React JS

De viktigaste intervjufrågorna och svaren för React JS

1) Förklara den virtuella DOM:n och hur avstämning fungerar i React.

Svar:

Den virtuella DOM:n är en minnesbaserad representation av användargränssnittet som React underhåller för att effektivt beräkna UI-ändringar. När tillstånd eller props muterar, renderar React ett nytt virtuellt DOM-träd och kör sedan en olika algoritm mot det föregående trädet för att upptäcka den minimala uppsättningen verkliga DOM-operationer som krävs. Denna process, kallad avstämning, minimerar layoutförstöring och kostsamma webbläsaromflöden. React assigns nycklar till element i listor för att hjälpa den att matcha noder mellan renderingar, och den använder heuristik (som att jämföra typer och nycklar) för att avgöra om noder ska uppdateras, ändras ordning eller tas bort. Fördelarna inkluderar förutsägbara uppdateringar, mindre yta för buggar och bättre prestanda i komplexa användargränssnitt.

Exempel:

Rendera en dynamisk lista med chattmeddelanden: med hjälp av stable key värden (meddelande-ID:n) läggs endast nya meddelanden till i DOM:n medan befintliga noder förblir orörda, vilket undviker onödiga omrenderingar.

👉 Gratis PDF-nedladdning: Intervjufrågor och svar om React JS


2) Vilka olika typer av komponentlivscykler finns det i React, och hur mappas Hooks till dem?

Svar:

React-komponenter går igenom monterings-, uppdaterings- och avmonteringsfaser. I klasskomponenter används livscykelmetoder som componentDidMount, shouldComponentUpdate, componentDidUpdateoch componentWillUnmount styr biverkningar, renderingsbeslut och rensning. I funktionskomponenter, krokar tillhandahålla motsvarande funktioner: useEffect hanterar effekter efter rendering; rensningsfunktioner inuti useEffect kör vid avmontering eller före nästa effekt; useMemo och useCallback kontrollmemoisering; och useRef behåller föränderliga referenser över renderingar. Fördelarna med Hooks inkluderar kompositionsförmåga, färre "detta"-bindningsproblem och enklare återanvändning av logik genom anpassade hookar, medan den största nackdelen är behovet av att lära sig Hooks regler och beroendehantering.

Svara med exempel:

  • Monteringseffekt: useEffect(() => fetchData(), []).
  • Rensning vid avmontering: useEffect(() => { start(); return stop; }, []).

3) Hur väljer man mellan klientsidesrendering (CSR), serversidesrendering (SSR), statisk webbplatsgenerering (SSG) och inkrementell statisk regenerering (ISR) för en React-applikation?

Svar:

Renderingsstrategin bör styras av krav på användarupplevelse, dataaktualitet, SEO-behov, infrastrukturbegränsningar och utvecklingshastighet. CSR passar mycket interaktiva appar bakom autentisering där SEO är sekundärt. SSR ger första omskrivningen verklig data för offentliga sidor, vilket förbättrar tid till första byte och SEO men med högre serverkostnader. SSG förberäknar sidor vid byggtid för utmärkt hastighet och cachning när data ändras sällan. ISR uppdaterar statiska sidor stegvis på begäran, vilket erbjuder en balans mellan uppdateringsfrekvens och prestanda. Faktorerna inkluderar cachelagring, personalisering, latens för globala målgrupper och driftskomplexitet.

Tabell: Fördelar kontra nackdelar

Tillvägagångssätt Fördelar Nackdelar
CSR Enkel hosting, rik interaktivitet Långsammare första målning, svagare SEO
SSR Bra SEO, färsk data vid första laddningen Högre serverbelastning, komplexitet
SSG Snabb, billig, CDN-vänlig Inaktuellt innehåll tills ombyggnad
ISR Snabb med kontrollerad fräschör Fler rörliga delar att hantera

4) Vilken strategi för tillståndshantering bör användas: lokalt tillstånd, kontext, Redux eller frågebibliotek?

Svar:

Välj enklaste verktyget som hanterar problemets egenskaper. Komponent-lokalt tillstånd via useState or useReducer är idealisk för isolerade UI-problem. Sammanhang fungerar för läsförståeliga, applikationsomfattande värden (tema, språk, aktuell användare) men är inte optimerad för högfrekventa uppdateringar över stora träd. Redux eller liknande händelsebaserade butiker utmärker sig när du behöver förutsägbarhet, tidsbaserad felsökning, mellanprogramvara och strikta enkelriktade dataflöden. Bibliotek för datahämtning (till exempel mönster i React Query-stil) hantera serverns tillståndslivscykler – cachning, deduping, omhämtningsstrategier och synkronisering – vilket minskar standardiseringen. En pragmatisk arkitektur använder ofta lokalt tillstånd + Kontext för konfiguration + ett servertillståndsbibliotek, och reserverar Redux för komplexa arbetsflöden.

Exempel:

En instrumentpanel använder React Query för API-cachning, kontext för tema och useReducer inuti komplexa widgetar för lokal händelsehantering.


5) Vad är skillnaden mellan useEffect och useLayoutEffect, och när gäller båda?

Svar:

useEffect körs efter att webbläsaren har ritat, vilket gör den lämplig för icke-blockerande uppgifter som datahämtning, prenumerationer och loggning. useLayoutEffect exekveras synkront efter DOM-mutationer men före paint, vilket möjliggör mät- och layoutjusteringar som måste ske utan flimmer (till exempel att läsa elementstorlekar och synkront återanvända stilar). Nackdelen med useLayoutEffect är att den kan blockera målningen och skada responsen om den används för mycket. En bra regel är att börja med useEffect för biverkningar och sök efter useLayoutEffect endast när du måste mäta eller synkront mutera layouten för att säkerställa visuell korrekthet.

Svara med exempel:

  • useEffecthämta användarprofil efter rendering.
  • useLayoutEffect: mät storleken på ett verktygstips för att placera det före målning.

Snabb jämförelse

Karakteristisk useEffect användLayoutEffekt
Tidpunkten Efter målning Före målning
Användningsfall Data, prenumerationer Mätningar, korrigeringar för synkron layout
Risk Mindre stöt om den är tung Blockerar färg om den är tung

6) Förklara hur nycklar fungerar i listor och nackdelarna med att använda arrayindex.

Svar:

Nycklar gör det möjligt för Reacts avstämning att korrekt identifiera listobjekt mellan renderingar. Stabila, unika nycklar gör det möjligt för React att ändra ordning, infoga eller ta bort objekt med minimal DOM-omsättning. arrayindex som nycklar är problematiskt när objekt kan ändra ordning, infogas eller tas bort eftersom React kan associera tidigare tillstånd med fel element, vilket orsakar subtila buggar (till exempel felaktiga inmatningsvärden eller animationer). Bästa praxis är att använda en oföränderlig, domänspecifik identifierare, såsom ett databas-ID. Om listan är helt statisk och aldrig ändrar ordning är index acceptabla, men detta är undantaget snarare än regeln.

Exempel:

En drabar Kanban-tavla bör använda kort-ID:n, inte index, för att bevara komponentidentiteten under dra-och-släpp.


7) Var används memoiseringstekniker i React, och vilka är deras fördelar och nackdelar?

Svar:

Memorisering minskar onödiga beräkningar och omrenderingar genom att återanvända tidigare resultat när indata inte har ändrats. I React, React.memo utdata för cachekomponenter, useMemo cachar dyra beräkningar, och useCallback Memoriserar funktionsidentiteter som skickas till underordnade funktioner. De främsta fördelarna är prestandastabilitet och minskad CPU-användning vid hög interaktion. Nackdelar inkluderar komplexitet, potentiella buggar med inaktuell cache om beroenden är felaktiga och minnesoverhead.

Tabell: Olika sätt att memorera

Typ Syfte Typiska faktorer att beakta
React.memo(Component) Hoppa över omrendering om rekvisita är ytlig-likvärdiga Prop volatilitet, barnkostnad
useMemo(fn, deps) Cachelagra beräknade värden Kostnad för beräkning kontra minne
useCallback(fn, deps) Stabil funktionsidentitet Beroendets korrekthet

Svara med exempel:

Memorera en filtrerad, sorterad datamängd för ett rutnät med hjälp av useMemooch omsluter cellrenderingskomponenter med React.memo för att undvika återkommande stormar.


8) Föredrar du kontrollerade eller okontrollerade komponenter för formulär? Diskutera fördelar, nackdelar och typer av formulärtillstånd.

Svar:

Kontrollerade komponenter binda indata till React-tillstånd via value och onChange, vilket möjliggör validering, maskering och villkorligt användargränssnitt härlett från en enda sanningskälla. Fördelarna är förutsägbarhet och enkel integration med andra tillstånd; nackdelarna inkluderar kostnad för omrendering vid varje tangenttryckning utan optimering. Okontrollerade komponenter förlita sig på DOM som sanningskälla med hjälp av referenser, vilket ger lägre omkostnader och enklare kopplingar för grundläggande formulär, men mindre centraliserad validering. För komplexa arbetsflöden är ett hybridmönster vanligt, med kontrollerade indata för kritiska fält och okontrollerade för stora, texttunga områden.

Exempel:

Ett registreringsformulär använder kontrollerade fält för validering av e-postadress och lösenord, medan ett textområde för anteckningar är okontrollerat för att minska omkostnaderna för rendering.


9) När skulle man använda Context kontra en anpassad hook, och vad är skillnaden mellan dem rent konceptuellt?

Svar:

Sammanhang är en transportmekanism för värden som många komponenter behöver, vilket undviker propellerborrning. Den hanterar inte tillståndet själv; den exponerar det helt enkelt för underordnade komponenter. anpassad krok kapslar in återanvändbar logik – som kombinerar tillstånd, effekter och externa tjänster – och returnerar värden och funktioner. Använd kontext för att tillhandahålla delad, mestadels läsbar konfiguration eller för att exponera en butik, och använd anpassade hookar för att implementera butikens beteende eller för att orkestrera problem som autentisering, funktionsflaggor eller datahämtningspolicyer. De två kompletterar varandra: ett gemensamt mönster är useAuth() som en specialanpassad krok med stöd av en AuthContext.

Svara med exempel:

AuthProvider tillhandahåller användare och tokens via Context; useAuth hanterar biverkningar vid inloggning, uppdatering och utloggning.


10) Kan du beskriva strategier för prestandajustering för stora React-applikationer, inklusive egenskaper hos långsamma rendering och livscykel-hotspots?

Svar:

Prestandajustering börjar med mätning. Identifiera långsamma vägar med hjälp av React DevTools Profiler och webbläsarens prestandapaneler för att hitta avstämningsrelaterade hotspots och dyra commits. Taktikerna inkluderar statlig lokalitet (hålla staten nära sina konsumenter), memoisation (React.memo, useMemo, useCallback), listvirtualisering för långa listor, koduppdelning med lazy loading för att minska det initiala paketet, och avstudsning eller strypning högfrekventa händelser. För serverbaserad data, implementera cachning med ett frågebibliotek och utnyttja spänningsvänlig mönster för smidigare inläsning. Var uppmärksam på livscykelrelaterade hotspots, till exempel effekter som körs för ofta på grund av breda beroendematriser eller komponenter som renderas om på grund av att kontextvärden ändras ofta.

Svara med exempel:

Virtualisera en tabell med 10 000 rader med hjälp av ett fönsterbibliotek; lazy-load tunga diagram bakom ruttbaserad koddelning för att förbättra den initiala ritningen.


11) Vad är skillnaden mellan props och state i React?

Svar:

Både props och state påverka hur komponenter renderas, men deras syfte och livscykel skiljer sig fundamentalt åt. rekvisita (förkortning för egenskaper) är oföränderliga indata som skickas från en förälderkomponent till en underordnad komponent och definierar konfiguration eller data för rendering. nedåt i Reacts enkelriktade dataflöde och bör aldrig modifieras av den mottagande komponenten. Ange, å andra sidan, är föränderlig och underhålls internt av komponenten. Den avgör dynamiskt beteende som förändras över tid, såsom formulärinmatningsvärden eller växlad synlighet.

Tabell över viktiga skillnader:

Faktor rekvisita Ange
Föränderlighet Oföränderlig Föränderlig
Ägande Godkänd av förälder Ägs av komponent
Uppdateringsmetod Föräldraåtergivningar useState or setState
Användningsfall konfiguration Dynamiska gränssnittsändringar
Livscykel Existerar under rendering Kvarstår, utlöser omrendering

Exempel:

A <Button color="blue" /> använder rekvisita för att bestämma färg, medan en clicked booleskt i sitt tillstånd växlar visuell feedback.


12) Förklara komponentarkitekturmönstret i React och de olika sätt som komponenter klassificeras.

Svar:

React-applikationer följer en komponentbaserad arkitektur, vilket bryter ner användargränssnittet i små, återanvändbara byggstenar. Komponenter kan kategoriseras efter deras Syftet och ansvaret:

  1. Presentationskomponenter (dumma) – Fokusera på användargränssnittet, ta emot data via rekvisita och hantera sällan tillstånd.
  2. Containerkomponenter (smarta) – Hanterar logik, hämtar data och hanterar tillstånd; de renderar presentationskomponenter.
  3. Komponenter av högre ordning (HOC) – Funktioner som tar en komponent och returnerar en förbättrad version med ytterligare beteende.
  4. Rena komponenter – Optimera prestanda genom att ytligt jämföra rekvisita och tillstånd.
  5. Funktionella kontra klasskomponenter – Funktionella komponenter (med krokar) är nu att föredra för läsbarhet och prestanda.

Exempel:

A <UserProfile /> komponenten kan vara presentationsmässig, ta emot användarinformation, medan <UserProfileContainer /> hämtar data och hanterar dess livscykel.


13) Hur hanterar React felgränser, och varför är de viktiga?

Svar:

Felgränser är speciella React-komponenter som fångar JavaSkriptfel var som helst i deras underordnade komponentträd under rendering, livscykelmetoder eller konstruktorer. De förhindrar hela appkrascher genom att isolera fel till specifika underträd. Du kan implementera ett med hjälp av componentDidCatch(error, info) och static getDerivedStateFromError() i en klasskomponent.

fördelar:

  • Bevara gränssnittets stabilitet genom att visa reservgränssnitt.
  • Registrera och logga fel för analys.
  • Förhindra kaskadgående avmonteringar.

Exempel:

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) Vad är React Fragments, och hur skiljer de sig från wrapper element?

Svar:

Reagera Fragment (<></>) låter dig gruppera flera element utan att lägga till extra noder i DOM:en. Detta är viktigt för en renare struktur, särskilt i listor, tabeller och semantisk HTML där ytterligare omslag kan orsaka layout- eller tillgänglighetsproblem. Till skillnad från omslag <div>s, Fragment renderas inte till DOM och har därför prestanda- och semantiska fördelar.

Exempel:

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

Skillnadstabell:

Faktor fragment <div> Wrapper
DOM-utdata Ingen Lägger till extra nod
Användningsfall Strukturell grouping Styling eller layout
Prestanda Bättre Liten omkostnad

15) Vilken React Hook skulle du använda för prestandaoptimering och varför?

Svar:

Prestandakänsliga React-komponenter förlitar sig ofta på memo-krokar och lat laddning för att minimera redundant arbete. Vanliga krokar inkluderar:

  • useMemo → Cachar beräkningsmässigt dyra resultat.
  • useCallback → Förhindrar onödiga underordnade renderingar på grund av ändringar i funktionsidentitet.
  • useTransition → Skjuter upp icke-brådskande uppdateringar för ett smidigare användargränssnitt.
  • useDeferredValue → Fördröjer tunga beräkningar tills efter omedelbara interaktioner.

Exempel:

Ett stort datanät med hjälp av useMemo för filtrerade resultat kan minska CPU-förbrukningen med 50 % eller mer.

fördelar:

  • Minskar slöseri med rendering.
  • Håller användargränssnittet responsivt under belastning.

Nackdel:

  • Kräver beroendeprecision; inaktuella cachefel kan uppstå om de hanteras felaktigt.

16) Vad är React-portaler, och vilka är deras fördelar?

Svar:

Portals tillåta React-komponenter att rendera underordnade element till en DOM-nod utanför deras överordnade hierarki, vanligtvis för modaler, verktygstips eller rullgardinsmenyer som visuellt måste "undankomma" överflödes- eller staplingskontexter. Implementerad med hjälp av ReactDOM.createPortal(child, container), de bibehåller konsistensen av händelsebubblor, så händelsehanterare fungerar som om elementet förblev inom sin ursprungliga hierarki.

Fördelstabell:

Fördel BESKRIVNING
Strukturellt oberoende Rendera utanför föräldraträdet
CSS/Stackningskontroll Undvik overflow: hidden eller z-indexproblem
Händelseförökning Reacts syntetiska händelser bubblar fortfarande korrekt
reus Förmåga Idealisk för globala överlagringar

Exempel:

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

17) Förklara hur React Router hanterar navigering och tillstånd mellan sidor.

Svar:

React Router är ett deklarativt routingbibliotek som synkroniserar användargränssnittet med webbläsarens URL. Den använder historik-API att manipulera sessionshistorik utan att helsidesladdningar krävs. Kärnkoncept inkluderar rutter, vänsteroch Classic Outlet för kapslad routing. Biblioteket stöder dynamiska rutter, URL parametraroch navigeringskrokar (useNavigate, useParams, useLocationReact Router v6 introducerade en förenklad syntax och data-API:er för Lastaren och handling funktioner, förbättrar SSR-integration och tillståndshantering.

Exempel:

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

Fördelar:

  • Möjliggör navigering på en sida.
  • Bibehåller rullningsposition och historik.
  • Integreras snyggt med lazy loading för bättre prestanda.

18) Vilka olika sätt kan man hantera biverkningar i React-applikationer?

Svar:

Biverkningar hänvisar till åtgärder som påverkar något utanför en komponents omfattning (API-anrop, DOM-manipulation, prenumerationer). De viktigaste verktygen inkluderar:

  1. useEffect för klient-sideffekter efter rendering.
  2. Händelsehanterare för användarstyrda effekter.
  3. Anpassade krokar att återanvända effektlogik (till exempel useFetch).
  4. middle~~POS=TRUNC (som Redux Saga eller Thunk) för komplex asynkron orkestrering.
  5. React Query eller SWR för att hantera servertillstånd och automatiskt hämta livscykler igen.

Exempel:

A useEffect hämtar data vid montering:

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

fördelar:

Förenklad asynkron hantering, bättre inkapsling och tydligare livscykelkontroll.


19) Är React ett ramverk eller ett bibliotek? Diskutera de faktorer som definierar skillnaden.

Svar:

React är officiellt en , inte ett fullfjädrat ramverk. Det fokuserar enbart på vylager, tillhandahåller rendering, tillstånd och komponent-abstracutan att tvinga fram routing, datahämtning eller byggstruktur.

Jämförelsetabell:

Faktor Bibliotek (React) Ramverk (Angular, Vue)
Omfattning Visa rendering Fullständig MVC-arkitektur
Påstridig Låg Hög
kontroll Utvecklardriven Ramverksdriven
Flexibilitet Hög Begränsad av konventioner
Inlärningskurva Moderate Högre på grund av komplexitet

Reacts ekosystem (Redux, Router, Query, Next.js) bildar effektivt ett "meta-ramverk" som erbjuder modulär kompositionsbarhet som gör det möjligt för utvecklare att bygga sin egen arkitektur.


20) När bör man använda React.lazy och Suspense, och vilka är deras fördelar?

Svar:

React.lazy möjliggör koduppdelning genom att dynamiskt ladda komponenter endast när det behövs, medan Suspense tillhandahåller ett reservgränssnitt tills komponenten är redo. Denna kombination förbättrar prestandan vid initial laddning och användarupplevd respons.

Exempel:

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

Fördelstabell:

Fördel Förklaring
Prestanda Laddar kod på begäran
Användarupplevelse Elegant laddningsalternativ
Buntstorlek Mindre initialt paket
Enkelhet Nativt React API, minimal installation

Bästa metoder:

  • Linda in flera lata komponenter i en Suspense-gräns.
  • Använd meningsfulla reservindikatorer för tillgänglighet.

21) Förklara vad React Server Components (RSC) är och deras fördelar.

Svar:

React Server Components (RSC) är en viktig innovation som introducerats för att förbättra prestanda och utvecklarupplevelse genom att tillåta komponenter att rendera på servern utan att skicka deras JavaSkript till klientenDe körs helt på servern, hämtar data, läser från databaser eller utför I/O-operationer säkert innan de strömmar serialiserad utdata till klienten.

fördelar:

  • Mindre buntstorlek — Ingen klient-JS för endast server-logik.
  • Förbättrad prestanda — Hämtning av data på serversidan minskar vattenfall.
  • Säkerhet — Känslig kod når aldrig webbläsaren.
  • Bättre cachning — Serverkomponenter är cachelagrade vid kanten.

Exempel:

A <ProductList /> serverkomponenten kan hämta data direkt från en databas och skicka resultaten till en <ProductCard /> klientkomponenten.


22) Vad är skillnaden mellan React-hydrering och försoning?

Svar:

Även om båda termerna innebär att React uppdaterar användargränssnittet, skiljer sig deras syfte åt:

  • Försoning är processen att jämföra det virtuella DOM-trädet med dess tidigare version för att bestämma den minsta uppsättningen DOM-uppdateringar.
  • hydra~~POS=TRUNC, å andra sidan, är processen att koppla Reacts händelselyssnare och interna strukturer till serverrenderad HTML på klientsidan, och förvandla statisk markup till en helt interaktiv app.

Jämförelsetabell:

Faktor Försoning hydra~~POS=TRUNC
Trigger Klienten återger Initial sidinläsning (SSR)
Syfte Uppdatera DOM effektivt Gör SSR HTML interaktiv
Omfattning Virtuell DOM-differens Händelsebindning + tillståndsåterkoppling
Frekvens Flera gånger En gång efter SSR-rendering

Exempel:

Efter att en Next.js-app skickar förrenderad HTML, React hydrater så att komponenterna svarar på händelser utan att rendera allt igen.


23) Hur förbättrar samtidig rendering användarupplevelsen i React 18+?

Svar:

Samtidig rendering gör det möjligt för React att avbryta, pausa eller återuppta renderingsarbete baserat på användarens prioritet. Detta förhindrar att användargränssnittet fryser under tunga beräkningar eller omrendering. Funktioner som useTransition och useDeferredValue utnyttja denna förmåga för att separera brådskande uppdateringar (som digping) från icke brådskande sådana (som filtrering).

Fördelar:

  • Smidiga, responsiva interaktioner.
  • Tidsslicing för att förhindra att huvudtråden blockeras.
  • Förutsägbar prioritering för bättre UX.

Exempel:

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

Här, tackping förblir flytande även vid filtrering av stora datamängder eftersom React schemalägger icke-brådskande uppdateringar samtidigt.


24) Vilka olika sätt kan man utföra tester i React-applikationer?

Svar:

Reaktionstestning kan klassificeras i enhet, integreringoch början till slut nivåer.

Tabell över testmetoder:

Typ Verktyget Syfte
Enhet det finns Testa isolerade funktioner/komponenter
Integration React Testing Library Testa UI-interaktioner och tillståndsändringar
E2E Cypress / Dramatiker Testa användarflöden i riktiga webbläsare

Bästa metoder:

  • Föredra React Testing Library över enzym (modern, DOM-orienterad).
  • Mock-API:er med hjälp av msw (Skämservicearbetare).
  • Undvik att testa implementeringsdetaljer – fokusera på beteende.

Exempel:

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

25) Vilka byggverktyg och bundlers används oftast med React, och vad är deras skillnader?

Svar:

React kan integreras med flera bundlare och kompilatorer, som var och en är optimerad för olika användningsfall.

Jämförelsetabell:

Verktyget Egenskaper Fördelar Nackdelar
Webpack Mycket konfigurerbar Mogen, plugin-rik Komplex uppställning
skruv ESM-baserad, blixtsnabb utvecklingsserver Omedelbar HMR, modern syntax Begränsat stöd för äldre plugins
Paket Nollkonfiguration Automatisk optimering Less flexibel
esbygga Go-baserad kompilator Mycket snabbt Färre ekosystem-plugins

Exempel:

Moderna projekt använder ofta skruv för utvecklingshastighet och esbygga i CI/CD-pipelines för effektiva produktionsbyggnationer.


26) Hur utökar Next.js Reacts möjligheter?

Svar:

Next.js är en Reagera ramverk tillhandahåller en gedigen arkitektur för routing, SSR och statisk generering. Den introducerar hybridrenderingsmodeller, API-rutter och edge-ready distributionsfunktioner.

fördelar:

  • Inbyggd SSR/SSG/ISR stöd.
  • App-router med React Server-komponenter.
  • Bildoptimering och middleware för prestanda och säkerhet.
  • Enkla API-rutter för serverlösa funktioner.

Exempel:

app/page.js för SSR-renderade sidor; app/api/route.js för serverslutpunkter.

SammanfattningsvisNext.js möjliggör React-appar i produktionsklass med minimal konfiguration.


27) Vilka är några vanliga prestandafallgropar i React, och hur kan man undvika dem?

Svar:

Vanliga fallgropar inom React-prestanda inkluderar:

  1. Onödiga omrenderingar — Åtgärda med hjälp av React.memo eller dela upp komponenter.
  2. Skapande av inline-objekt/matris — Använd useMemo för stabila referenser.
  3. Stora listor — Implementera fönsterfunktioner (react-window, react-virtualized).
  4. Tunga beräkningar — Memorera eller avlasta till webbarbetare.
  5. Överanvändning av kontext — Frekventa uppdateringar sprider sig djupt; föredrar härlett tillstånd.

Exempel:

Om du klarar { a: 1 } infogat till en memoariserad komponent, renderas den om på varje föräldrarendering. Åtgärda genom att memoarisera objektet.

Tabell för prestandatips:

Utgåva Optimeringsteknik
Återrenderar React.memo, useCallback
Dyra beräkningar useMemo, Webbarbetare
Stora datamängder virtualisering
Frekventa kontextuppdateringar Lokalisera tillstånd

28) Förklara skillnaden mellan useReducer och useState.

Svar:

Båda hookarna hanterar tillstånd, men de skiljer sig åt i komplexitet och kontroll.

  • useState är idealisk för enkla, isolerade tillståndsövergångar.
  • useReducer centraliserar komplex tillståndslogik i en reduceringsfunktion, Med användning av dispatch åtgärder för förutsägbara uppdateringar.

Jämförelsetabell:

Faktor useState användReducer
syntax [value, setValue] [state, dispatch]
Komplexitet Enkelt Måttlig till komplex
Användningsfall Oberoende stater Relaterade eller kapslade tillstånd
Debugging Less mångordig Enklare via loggade åtgärder
Exempelvis Formulärväxlare Formulärvalidering eller flerstegsformulär

Exempel:

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

29) Hur kan man förbättra tillgängligheten (a11y) i React-applikationer?

Svar:

Tillgänglighet säkerställer att alla användare, inklusive de med funktionsnedsättningar, kan använda din app effektivt. React underlättar tillgänglighet genom semantisk markup och ARIA-attribut.

Bästa metoder:

  • Använda semantisk HTML (<button> vs <div onClick>).
  • Hantera fokus med hjälp av ref och tabIndex.
  • Använd ARIA-roller för dynamiska komponenter.
  • Se till att bilder har färgkontrast och textalternativ.
  • Utnyttja verktyg som eslint-plugin-jsx-a11y och yxkärna för revisioner.

Exempel:

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

fördelar:

  • Bredare publikräckvidd.
  • SEO-förbättring.
  • Överensstämmelse med WCAG-standarder.

30) Kan du beskriva hur koddelning och lazy loading skiljer sig åt, och när man ska använda var och en?

Svar:

Båda teknikerna optimerar buntstorlek och lastprestanda men skiljer sig åt i exekveringstidpunkt.

  • Code delning delar upp stora buntar i mindre bitar som kan lastas separat.
  • Lazy loading fördröjer inläsningen av dessa bitar tills de behövs.

Jämförelsetabell:

Faktor Code delning lat Loading
Definition Delar upp koden i bitar Laddar bitar på begäran
Verktyget Webpack, Vite React.lazy, dynamisk import()
Syfte Optimera paketstorleken Förbättra prestandan vid körning
Utförande Byggtid Runtime

Exempel:

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

Tillsammans minskar dessa tekniker tiden till interaktivitet och förbättrar den upplevda hastigheten för stora appar.


31) Förklara konceptet med renderingsproppar och hur det skiljer sig från högre ordningskomponenter (HOC).

Svar:

Rendera rekvisita är ett mönster i React där en komponent accepterar en fungera som rekvisita som talar om vad den ska rendera. Detta gör att komponentlogik kan delas mellan flera komponenter utan duplicering.

HOC:er, å andra sidan, linda en komponent och returnera en förbättrad version med injicerade props eller beteenden.

Jämförelsetabell:

Faktor Rendera rekvisita HOC
Genomförande Funktion som barn Funktionsomslagping komponent
Sammansättning Inline-kontroll Deklarativ omslagping
läsbarhet Ofta tydligare Kan orsaka omslagshelvete
Användningsfall Dynamisk renderingslogik Övergripande frågor

Exempel:

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

Render Props erbjuder bättre flexibilitet och undviker namnkollisioner som är vanliga i HOCs.


32) Vilka olika typer av specialbyggda krokar finns det och deras fördelar?

Svar:

Anpassade hooks inkapslar återanvändbar logik som kombinerar tillstånd, biverkningar och verktyg. De förbättrar kodens återanvändbarhet, separation av problem och testbarhet.

Typer och exempel:

  1. Statlig förvaltning krokar - useToggle, useForm.
  2. Hooks för datahämtning - useFetch, useQuery.
  3. UI/UX-krokar - useWindowSize, useDarkMode.
  4. Integrationskrokar - useLocalStorage, useMediaQuery.
  5. Prestandakrokar - useDebounce, useThrottle.

fördelar:

  • Centraliserad logisk återanvändning.
  • Renare komponenter.
  • Oberoende testning.

Exempel:

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) Hur hanterar man minnesläckor i React-applikationer?

Svar:

Minnesläckor uppstår när omonterade komponenter fortfarande innehåller referenser till resurser eller prenumerationer. De försämrar prestandan och orsakar oförutsägbart beteende.

Förebyggande tekniker:

  1. Rengöringseffekter in useEffect: useEffect(() => { const id = setInterval(logData, 1000); return () => clearInterval(id); }, []);
  2. Avbryt asynkrona samtal med hjälp av AbortController.
  3. Undvik att behålla gamla förslutningar refererar till gamla rekvisita/tillstånd.
  4. Avsluta prenumerationen på evenemang eller sockets vid avmontering.
  5. Använd React Profiler för att upptäcka långsam minnestillväxt.

Exempel:

I en chattapp, koppla alltid bort socket-lyssnare när en användare navigerar bort från chattrummet.


34) Vilka är de bästa metoderna för att hantera formulär i stora React-applikationer?

Svar:

Att hantera formulär i React-appar i företagsskala kräver en balans mellan kontroll, prestanda och underhållbarhet.

Bästa metoder:

  • Använd bibliotek som Myr, Reagera krokform, eller Slutlig blankett för validering och fältregistrering.
  • Gruppera relaterade fält med hjälp av kapslade komponenter eller kontexter.
  • Ansök schemavalidering (Japp, Zod) för konsekvensens skull.
  • Avbouncera tunga valideringar eller API-kontroller.
  • Behåll formulärets tillstånd lokaliserat om det inte behövs globalt.

Exempel:

React Hook Form minimerar omrenderingar genom att isolera inmatningstillstånd.

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

35) Vilka designmönster är mest användbara i React-utveckling, och vilka är deras egenskaper?

Svar:

React lämpar sig naturligt för flera mjukvarudesignmönster för underhållbar och skalbar UI-arkitektur.

Mönster BESKRIVNING Exempelvis
Containerpresentatör Separera logik (container) från användargränssnitt (presentatör) DataContainer → UIComponent
Kontrollerad-Okontrollerad Hantera formulärdata via state kontra DOM Formik kontra råa ingångar
Sammansatta komponenter Föräldrakontroller underordnad sammansättning <Tabs><Tab /></Tabs>
Leverantörsmönster Dela status via kontext Temaleverantör
Krokmönster Återanvänd tillståndsbaserad logik useAuth, useFetch

Exempel:

A Tabs komponenten exponerar kontext så <Tab> barn registrerar sig automatiskt – en ren tillämpning av Sammansatt komponent mönster.


36) Vilka är de viktigaste skillnaderna mellan React 18 och React 19?

Svar:

React 19 bygger vidare på React 18:s samtidiga grund med betydande nya funktioner.

Leverans Reagera 18 Reagera 19
Samtidig rendering infört Förbättrad med bättre spänning
Serverkomponenter Experimentellt Stabiliserad och integrerad
Åtgärder API Ej tillgänglig Ny standard för hantering av formuläråtgärder
Inmatning av tillgångar Manuell Automatisk resursinläsning
Förbättrad felhantering Grundläggande Granulär med gränskrokar

Viktiga fördelar:

React 19 fokuserar på enklare datamutationer, inbyggda formuläråtgärderoch förbättrad asynkron kontroll, vilket gör SSR och progressiv hydrering mer sömlös.


37) Hur fungerar mikrofrontend? ArchiTeknologiintegration med React, och vilka är dess fördelar?

Svar:

Mikrofrontend delar upp en stor webbapp i oberoende, utplacerbara frontend-moduler. I ett React-ekosystem är varje mikrofrontend en fristående app som kan integreras via Modulfederation, iframes, eller anpassade runtime-laddare.

fördelar:

  • Oberoende distribution och skalning.
  • Teamautonomi över olika teknikstackar.
  • Snabbare byggande av pipelines.

Exempel:

Använda Webpack Module Federation, team kan dynamiskt exponera React-komponenter i olika appar:

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

Nackdelar:

  • Delad tillståndshanteringskomplexitet.
  • Prestandakostnader från isolerade paket.

38) Vilka faktorer tar du hänsyn till när du skalar en React-applikation i produktion?

Svar:

Att skala React-applikationer innebär tekniska, arkitektoniska och operativa överväganden.

Nyckelfaktorer:

  1. Code struktur — använda monorepos (Nx/Turborepo) för modulär koddelning.
  2. Statlig ledning — segmentera lokala vs globala vs servertillstånd.
  3. Prestanda — lat laddning, memoisering, CDN-cachning.
  4. Övervakning — använd Sentry, Datadog eller LogRocket för fel och mätvärden.
  5. Testning och CI/CD — automatiserade pipelines och visuella regressionstester.

Exempel:

En stor e-handelsplattform skalar React-appar med Next.js för SSR, Redux Toolkit för förutsägbart tillstånd och mikrogränssnitt för isolerade vertikaler.


39) Hur testar man React-komponenter som använder asynkront beteende?

Svar:

Att testa asynkrona React-komponenter kräver synkronisering mellan testkörningen och komponentens tillståndsuppdateringar.

Bästa metoder:

  • Använda waitFor or findBy* frågor i React Testing Library.
  • Mocka hämtningsanrop eller API:er med hjälp av msw.
  • Föredra falska timers (jest.useFakeTimers()) för timeout-baserade effekter.

Exempel:

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

Detta säkerställer att testet väntar på Reacts asynkrona uppdateringar innan det gör assertions.


40) Förklara hur du skulle utforma en storskalig, underhållbar React-projektstruktur.

Svar:

Ett skalbart React-projekt måste balansera modularitet, tydlighet och teamsamarbete.

Rekommenderad mappstruktur:

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

Bästa metoder:

  • Använd absoluta importer med sökvägsalias.
  • Bibehåll strikt luddning (ESLint + Prettier).
  • Använda TypeScript för typsäkerhet.
  • Tillämpa komponentgränser med atomär design eller funktionsbaserad slicing.

Exempel:

I en verklig installation kan en "Användar"-funktion inkludera UserSlice.js, UserAPI.js, UserCard.jsxoch User.test.js, allt inom src/features/user/.


🔍 De bästa intervjufrågorna för React.js med verkliga scenarier och strategiska svar

1) Vilka är de viktigaste skillnaderna mellan funktionella komponenter och klasskomponenter i React.js?

Förväntat från kandidaten: Intervjuaren vill testa din förståelse för React-komponentarkitektur och moderna bästa praxis.

Exempel på svar:

"Funktionella komponenter är enklare och använder krokar för att hantera tillstånds- och livscykelmetoder, medan klasskomponenter använder this och livscykelmetoder som componentDidMountFunktionella komponenter är generellt att föredra idag eftersom de främjar renare kod, är enklare att testa och presterar bättre tack vare optimeringar i Reacts renderingsprocess.”


2) Kan du förklara hur den virtuella DOM:n fungerar i React?

Förväntat från kandidaten: Intervjuaren vill utvärdera din förståelse för Reacts kärnprestandamekanism.

Exempel på svar:

”Den virtuella DOM:en är en minnesbaserad representation av den verkliga DOM:en. När en komponents tillstånd ändras uppdaterar React först den virtuella DOM:en, jämför den med den tidigare versionen med hjälp av en process som kallas 'diffing' och uppdaterar sedan bara de delar av den verkliga DOM:en som har ändrats. Denna metod förbättrar prestandan genom att minimera direkt DOM-manipulation.”


3) Hur hanterar man tillstånd i en storskalig React-applikation?

Förväntat från kandidaten: Intervjuaren vill veta om din erfarenhet av tekniker och verktyg för statlig förvaltning.

Exempel på svar:

”I stora applikationer använder jag vanligtvis centraliserade tillståndshanteringsbibliotek som Redux eller Zustand. Redux ger ett förutsägbart dataflöde och gör felsökning enklare genom tidsresande felsökningsverktyg. För enklare applikationer föredrar jag att använda Context API och hooks för att undvika onödig komplexitet.”


4) Beskriv en tidpunkt då du optimerade React-prestanda.

Förväntat från kandidaten: Intervjuaren vill förstå din praktiska erfarenhet av prestationsoptimering.

Exempel på svar:

"I min tidigare roll renderades vår applikation om i onödan på grund av onödiga tillståndsändringar. Jag använde React.memo och useCallback hook för att förhindra onödiga omrenderingar. Jag analyserade även prestanda med hjälp av React Profiler och identifierade komponenter som behövde memoreras, vilket minskade renderingstiden med nästan 30 %.


5) Hur hanterar man biverkningar i React?

Förväntat från kandidaten: Intervjuaren vill bedöma din förståelse av hooks och livscykelhantering.

Exempel på svar:

"Jag hanterar biverkningar som API-anrop eller DOM-manipulationer med hjälp av useEffect Hook. Hooken låter mig specificera beroenden, vilket säkerställer att effekten bara körs när dessa beroenden ändras. Detta hjälper till att upprätthålla förutsägbart beteende och undvika oändliga loopar.”


6) Berätta om en utmanande bugg du stötte på i ett React-projekt och hur du löste den.

Förväntat från kandidaten: Intervjuaren vill bedöma dina problemlösnings- och felsökningsfärdigheter.

Exempel på svar:

”På en tidigare position stötte jag på ett fel där tillståndsuppdateringar inte återspeglades i användargränssnittet. Efter att ha undersökt detta insåg jag att problemet orsakades av att tillståndsobjektet muterades direkt istället för att skapa en ny kopia. Jag omstrukturerade koden för att använda oföränderliga uppdateringar, vilket löste problemet och förbättrade datakonsistensen.”


7) Hur hanterar ni formulärvalidering i React-applikationer?

Förväntat från kandidaten: Intervjuaren vill se om du förstår hur man implementerar validering av användarinmatning.

Exempel på svar:

”Jag använder vanligtvis kontrollerade komponenter för att hantera formulärinmatningar, i kombination med bibliotek som Formik eller React Hook Form för validering. Dessa verktyg förenklar hantering av fel, hantering av formulärstatus och integrering med tredjepartsvalideringsbibliotek som Yup.”


8) Beskriv en situation där du var tvungen att samarbeta med backend-utvecklare medan du arbetade med ett React-projekt.

Förväntat från kandidaten: Intervjuaren vill utvärdera dina samarbets- och kommunikationsförmågor.

Exempel på svar:

”I min senaste roll samarbetade jag nära med backend-utvecklare för att designa REST API:er för en dashboard-applikation. Vi kom överens om dataformat och slutpunkter under tidiga utvecklingsfaser. Jag skapade också mock responses för att fortsätta frontend-utvecklingen medan backend-applikationen byggdes, vilket säkerställde en smidig integration senare.”


9) Hur säkerställer ni att era React-komponenter är återanvändbara och underhållbara?

Förväntat från kandidaten: Intervjuaren vill veta om din strategi för komponentdesign och skalbarhet.

Exempel på svar:

”Jag följer principen att bygga små, fokuserade komponenter som hanterar ett ansvar. Jag använder också props för flexibilitet, och jag fortsätter att utforma modulärt med CSS-in-JS eller styled-components. Detta säkerställer att komponenter enkelt kan återanvändas och underhållas i hela projektet.”


10) Hur håller du dig uppdaterad om React.js-trender och bästa praxis?

Förväntat från kandidaten: Intervjuaren vill utvärdera ditt engagemang för kontinuerligt lärande.

Exempel på svar:

”Jag håller mig uppdaterad genom att följa Reacts officiella dokumentation och communitybloggar. Jag tittar också på föredrag från React-konferenser som React Conf och lyssnar på poddar som 'React Podcast'. Dessa resurser hjälper mig att hålla mig informerad om nya funktioner som samtidig rendering och serverkomponenter.”

Sammanfatta detta inlägg med: