React – pytania rekrutacyjne na poziomie Senior Frontend Developer

10 najbardziej popularnych pytań na rozmowie technicznej o React.

interview

react

frontend

1. Czym różni się useState od useRef?

useState przechowuje stan komponentu. Zmiana wartości powoduje ponowne renderowanie komponentu.

useRef przechowuje mutowalną wartość pomiędzy renderami, ale jej zmiana nie powoduje renderowania.

useState – dane wpływające na UI.

useRef – referencje do DOM, timery, poprzednie wartości, mutable values.

2. Jak działa useEffect i kiedy może powodować problemy?

useEffect służy do synchronizacji komponentu z zewnętrznymi systemami, np. API, event listenerami czy timerami.

Uruchamia się po zatwierdzeniu renderu (commit), a cleanup poprzedniego efektu wykonywany jest przed ponownym uruchomieniem efektu i przy odmontowaniu komponentu.

Problemy:

  • brak lub nieprawidłowe dependencies,
  • nieskończone pętle renderowania,
  • race conditions przy requestach API,
  • memory leaks przez brak cleanup,
  • niepotrzebne efekty do wyliczania danych, które można obliczyć podczas renderowania.

3. Czym jest stale closure i jak można go uniknąć?

Stale closure występuje, gdy funkcja korzysta z wartości stanu lub propsów przechwyconych podczas wcześniejszego renderowania.

Przykładowo callback w setInterval może odwoływać się do nieaktualnego stanu.

Rozwiązania:

  • poprawne dependency arrays,
  • functional state updates (setCount(prev => prev + 1)),
  • useRef do przechowywania aktualnej wartości, gdy jest to uzasadnione.

4. Jak działa mechanizm renderowania komponentów w React?

React działa w dwóch głównych etapach:

Render phase – React wywołuje komponenty, oblicza nowy Virtual DOM (drzewo elementów React) i porównuje go z poprzednim wynikiem.

Commit phase – wprowadza niezbędne zmiany do DOM, aktualizuje refy i uruchamia odpowiednie efekty.

Render nie oznacza automatycznie aktualizacji całego DOM. React aktualizuje tylko te fragmenty, które tego wymagają.

React może również przerwać lub ponowić renderowanie przed commit phase, szczególnie w Concurrent Rendering.

5. Kiedy używasz useMemo, useCallback i React.memo?

Wszystkie trzy mechanizmy służą optymalizacji wydajności, ale działają na różnych poziomach:

useMemo – zapamiętuje wynik kosztownego obliczenia.

useCallback – zapamiętuje referencję do funkcji.

React.memo – ogranicza ponowne renderowanie komponentu, jeśli jego propsy nie uległy zmianie (płytkie porównanie domyślne).

Nie stosuję ich automatycznie. Najpierw identyfikuję problem z wydajnością, a następnie optymalizuję konkretne miejsca.

6. Jak optymalizujesz wydajność dużej aplikacji React?

Zaczynam od pomiarów, np. React Profiler, Chrome DevTools i Lighthouse.

Najważniejsze techniki:

  • code splitting i lazy loading,
  • ograniczanie niepotrzebnych renderów,
  • odpowiednie zarządzanie stanem i jego lokalizacją,
  • memoizacja tam, gdzie przynosi korzyści,
  • wirtualizacja dużych list,
  • cache'owanie danych i optymalizacja requestów,
  • optymalizacja obrazów i assetów,
  • eliminowanie ciężkich zależności.

Kluczowe jest mierzenie efektów zmian, a nie optymalizowanie na ślepo.

7. Czym jest Context API i kiedy lepiej użyć zewnętrznego rozwiązania do zarządzania stanem?

Context API pozwala udostępniać dane wielu komponentom bez przekazywania propsów przez kolejne poziomy drzewa (prop drilling).

Sprawdza się przy danych współdzielonych, np.:

  • theme,
  • język,
  • dane użytkownika,
  • konfiguracja aplikacji.

Przy dużym, często aktualizowanym stanie może powodować niepotrzebne renderowanie konsumentów Contextu.

Wtedy rozważam Zustand, Redux Toolkit lub inne rozwiązanie oferujące selektory, kontrolę subskrypcji i lepszą separację stanu.

8. Jak organizujesz komponenty w dużej aplikacji?

Preferuję organizację feature-based, czyli podział według domen biznesowych, a nie wyłącznie typów plików.

Przykładowo:

src/
  features/
    authentication/
      components/
      hooks/
      services/
      types/
    products/
      components/
      hooks/
      services/
      types/
  shared/
    components/
    hooks/
    utils/
  app/
    providers/
    routes/

Dbam o:

  • single responsibility,
  • czytelne granice odpowiedzialności,
  • separację logiki biznesowej od prezentacji,
  • reużywalność bez nadmiernej abstrakcji,
  • jawne zależności między modułami.

Architektura powinna odzwierciedlać domenę aplikacji i ułatwiać jej dalszy rozwój.

9. Jak obsługujesz błędy w komponentach React?

Stosuję kilka poziomów obsługi błędów:

  • Error Boundaries – przechwytują błędy podczas renderowania komponentów potomnych, w lifecycle i konstruktorach.
  • try/catch – do obsługi błędów w kodzie synchronicznym i operacjach asynchronicznych.
  • obsługa błędów API – odpowiednie stany loading, error i retry.
  • logging i monitoring – np. Sentry.

Error Boundaries nie przechwytują błędów z event handlerów ani zwykłych callbacków asynchronicznych.

W większej aplikacji stosuję granice błędów na poziomie routingu lub poszczególnych feature'ów, aby awaria jednej części nie wyłączała całej aplikacji.

10. Czym różni się controlled component od uncontrolled component?

Controlled component – wartość pola jest zarządzana przez React poprzez state. Aktualizacje odbywają się przez onChange.

Uncontrolled component – stan wartości znajduje się w DOM, a React odczytuje go np. przez ref.

Przykład:

  • Controlled: formularze wymagające walidacji na bieżąco, dynamicznych zależności i kontroli nad UI.
  • Uncontrolled: proste formularze, integracje z bibliotekami zewnętrznymi, pola obsługiwane przez FormData.

Controlled daje większą kontrolę nad stanem, uncontrolled może być prostszy i ograniczać liczbę renderów.

Bonus: Na co szczególnie uważać podczas rozmowy na poziomie Senior?

Trzy rzeczy, które odróżniają odpowiedź seniora od odpowiedzi osoby znającej jedynie API React:

  1. Wyjaśniaj konsekwencje decyzji. Nie tylko czym jest useMemo, ale kiedy jego użycie może być niepotrzebnym narzutem.
  2. Mów o trade-offach. Context vs Zustand, controlled vs uncontrolled, lokalny vs globalny state.
  3. Podawaj przykłady z produkcji. Pokaż, jak rozwiązywałaś problemy z renderowaniem, requestami, architekturą czy obsługą błędów.

Naucz się uzasadniać decyzje techniczne. To właśnie jest różnica między midem a seniorem podczas rozmowy technicznej.