Przejdź do treści

INP w React: 5 błędów, które psują Interaction to Next Paint

Maciej Sala

Founder StriveLab

11 min czytaniaAktualizacja

Szybka odpowiedź: jak poprawić INP w aplikacji React?

  • INP mierzy czas od interakcji do odrysowania, a dobry wynik to do 200 ms dla 75% wizyt.
  • Pięć wzorców psujących INP to stan za wysoko w drzewie, ciężkie obliczenia w handlerze, tysiące elementów naraz, cały stan w jednym kontekście i walidacja przy każdym klawiszu.
  • Naprawy to przeniesienie stanu niżej, podział obliczeń, wirtualizacja list i rozdzielenie kontekstów.
  • Zacznij od danych terenowych, żeby ustalić, która interakcja i która faza są wolne.
  • useTransition i useDeferredValue obniżają priorytet renderowania, ale nie przerywają pojedynczego obliczenia.

Dlaczego INP jest problemem właśnie w aplikacjach React

Aby precyzyjnie podejść do problemu, musimy rozłożyć INP na podstawowe części. Każda interakcja przechodzi przez trzy krytyczne etapy, które bezpośrednio decydują o odczuciach użytkownika. Pierwszym z nich jest , czyli czas od rozpoczęcia interakcji do rozpoczęcia wykonywania callbacków zdarzeń. Faza przetwarzania obejmuje wykonywanie tych callbacków, w tym pracę Reacta wykonaną przed ich zakończeniem. Całość zamyka , liczony od zakończenia callbacków do odrysowania następnej klatki. Może obejmować dalszą pracę JavaScriptu, render Reacta, przeliczanie stylów, układu i rysowanie. Czas interakcji to suma wszystkich trzech etapów, a INP raportuje praktycznie najdłuższą interakcję z całej wizyty na stronie. Przy dużej liczbie interakcji pomija jedną najdłuższą na każde 50, żeby pojedynczy wyjątek nie zawyżał wyniku. W aplikacjach SPA ma to dodatkowe znaczenie, ponieważ przejścia między widokami bez przeładowania strony wliczają się do jednego pomiaru INP.

W rozbudowanych aplikacjach React każdy z tych etapów może się wydłużyć z innego powodu. Input delay rośnie, gdy w chwili kliknięcia główny wątek jest zajęty hydratacją albo przeciągającym się renderowaniem. Czas przetwarzania wydłużają obliczenia i synchroniczne aktualizacje wykonywane w callbackach zdarzeń. Render Reacta uruchomiony po zakończeniu callbacków, ale przed następną klatką, wydłuża presentation delay, podobnie jak kosztowne przeliczanie stylów, układu i rysowanie. Ten sam rodzaj pracy może więc trafić do różnych faz, zależnie od momentu wykonania. Rozstrzyga to ślad w panelu Performance.

Wzorzec 1: Re-render całego drzewa przy każdej interakcji

Częstym błędem pogarszającym INP w React jest osadzenie stanu na zbyt wysokim poziomie drzewa komponentów, a naprawia go przeniesienie stanu niżej albo memoizacja komponentów, które od niego nie zależą. Przypadkowe kliknięcie lub wprowadzenie chociażby jednego znaku w formularzu natychmiast inicjuje przebudowę tych komponentów, które kompletnie nie wykorzystują tej zmodyfikowanej wartości.

Code
// ŹLE: jeden stan steruje wszystkim, a każda zmiana wymusza re-render całej listy
function Dashboard() {
  const [search, setSearch] = useState('')
  const [items] = useState(() => generateItems(2000))
 
  return (
    <div>
      <input value={search} onChange={(e) => setSearch(e.target.value)} />
      {/* Ta lista przelicza się przy każdym znaku w search, choć od niego nie zależy */}
      <ExpensiveList items={items} />
    </div>
  )
}

W tym przykładzie, bez memoizacji i optymalizacji React Compilera, zmiana pola wyszukiwania powoduje ponowny render ExpensiveList, mimo że lista nie korzysta z wartości search. Przeliczanie dwóch tysięcy elementów może wydłużyć interakcję, szczególnie na słabszym urządzeniu. Skalę tego kosztu sprawdzisz w pomiarze, ponieważ sama liczba elementów nie przesądza o złym INP.

Rozwiązanie zaczyna się od memoizacji komponentu, który nie powinien reagować na zmianę:

Code
// DOBRZE — ExpensiveList nie zależy od search, więc go izolujemy
const ExpensiveList = memo(function ExpensiveList({
  items,
}: {
  items: Item[]
}) {
  return (
    <ul>
      {items.map((item) => (
        <li key={item.id}>{item.name}</li>
      ))}
    </ul>
  )
})

Dzięki memo React pomija ponowny render listy, dopóki jej propsy się nie zmienią. W świeżym projekcie React Compiler zrobi część tej pracy automatycznie, ale nadal musisz rozumieć granice renderowania. Kompilator nie naprawi źle ustawionego stanu.

Wzorzec 2: Ciężkie zadanie synchroniczne w event handlerze

Ciężkie zadanie synchroniczne w event handlerze to klasyczna przyczyna złego INP: użytkownik klika, a w odpowiedzi odpala się sortowanie, filtrowanie albo transformacja kilku tysięcy rekordów, wszystko synchronicznie, w jednym bloku. Długie obliczenia przenieś do Web Workera albo podziel na porcje, między którymi oddasz kontrolę przeglądarce. useTransition przydaje się do nadania aktualizacji UI niższego priorytetu, ale sam nie dzieli obliczeń.

Code
// ŹLE — sortowanie 10 000 rekordów blokuje główny wątek przed odrysowaniem
function ProductTable({ products }: { products: Product[] }) {
  const [sorted, setSorted] = useState(products)
 
  function handleSort(key: keyof Product) {
    const result = [...products].sort((a, b) => heavyCompare(a, b, key))
    setSorted(result)
  }
 
  return <Table data={sorted} onSort={handleSort} />
}

Problem polega na tym, że heavyCompare na dużym zbiorze potrafi zająć główny wątek na kilkaset milisekund. Przez ten czas przeglądarka nie odrysuje niczego, czyli ani efektu kliknięcia, ani nawet wskaźnika ładowania. W efekcie INP zmierzy całe to opóźnienie jako jedną fatalną interakcję.

Od Reacta 18 useTransition pozwala oznaczyć aktualizację jako , dzięki czemu React może dać pierwszeństwo pilnym aktualizacjom i przerwać renderowanie między jednostkami pracy. Funkcja przekazana do startTransition wykonuje się jednak od razu. Owinięcie nią synchronicznego sortowania nadal blokowałoby główny wątek w handlerze kliknięcia. W poniższym przykładzie w transition zmieniamy wyłącznie klucz sortowania, a sortowanie przenosimy do renderu o niższym priorytecie:

Code
// ZMIANA PRIORYTETU: sortowanie nadal jest jednym blokującym wywołaniem
function ProductTable({ products }: { products: Product[] }) {
  const [sortKey, setSortKey] = useState<keyof Product | null>(null)
  const [isPending, startTransition] = useTransition()
 
  const sorted = useMemo(
    () =>
      sortKey
        ? [...products].sort((a, b) => heavyCompare(a, b, sortKey))
        : products,
    [products, sortKey],
  )
 
  function handleSort(key: keyof Product) {
    startTransition(() => setSortKey(key))
  }
 
  return (
    <>
      {isPending && <SortingIndicator />}
      <Table data={sorted} onSort={handleSort} />
    </>
  )
}

React może wykonać pilną aktualizację z isPending ustawionym na true, jeszcze zanim zakończy render z nowym kluczem sortowania, ale trzeba pamiętać, że nie gwarantuje to jednak odrysowania wskaźnika przed rozpoczęciem sortowania. useMemo pomija obliczenie przy niezmienionych zależnościach, ale po zmianie sortKey wywołuje zwykłe synchroniczne sort(). React nie przerwie go w połowie, więc takie obliczenie nadal może opóźnić klatkę lub następną interakcję. Traktuj ten przykład jako zmianę priorytetu renderowania; gdy samo sortowanie jest długie, przenieś je do lub zastosuj algorytm, który potrafisz podzielić na porcje.

Wzorzec 3: Renderowanie tysięcy elementów naraz

Renderowanie tysięcy elementów naraz może pogorszyć INP w długich listach i tabelach, a rozwiązaniem jest wirtualizacja albo paginacja. Nawet jeśli każdy wiersz jest lekki, duży DOM zwiększa potencjalny koszt aktualizacji stylów, układu i rysowania. Zakres tej pracy zależy od zmian wywołanych interakcją; samo kliknięcie nie wymusza przeliczenia całej listy. Rozwinięcie wiersza lub zmiana filtra potrafi jednak uruchomić kosztowną aktualizację. Samo przewijanie nie jest wliczane do INP, ale kliknięcia w takiej liście już tak.

Code
// 5000 wierszy w DOM zwiększa potencjalny koszt aktualizacji listy
function LogViewer({ logs }: { logs: LogEntry[] }) {
  return (
    <div className="h-[600px] overflow-auto">
      {logs.map((log) => (
        <LogRow key={log.id} entry={log} />
      ))}
    </div>
  )
}

Odpowiedzią jest , czyli renderujemy wiersze w widocznym oknie i niewielki zapas, a resztę zastępujemy odpowiednio wysokim pustym obszarem. W TanStack Virtual możesz mierzyć rzeczywistą wysokość wierszy, dzięki czemu pozycje uwzględnią również zawijający się tekst:

Code
// DOBRZE: ograniczamy DOM i mierzymy rzeczywistą wysokość wierszy
import { useVirtualizer } from '@tanstack/react-virtual'
import { useRef } from 'react'
 
function LogViewer({ logs }: { logs: LogEntry[] }) {
  const parentRef = useRef<HTMLDivElement>(null)
 
  const virtualizer = useVirtualizer({
    count: logs.length,
    getScrollElement: () => parentRef.current,
    getItemKey: (index) => logs[index].id,
    estimateSize: () => 48,
    overscan: 10,
  })
 
  return (
    <div ref={parentRef} className="h-[600px] overflow-auto">
      <div style={{ height: virtualizer.getTotalSize(), position: 'relative' }}>
        {virtualizer.getVirtualItems().map((row) => (
          <div
            key={row.key}
            data-index={row.index}
            ref={virtualizer.measureElement}
            style={{
              position: 'absolute',
              top: 0,
              transform: `translateY(${row.start}px)`,
              width: '100%',
            }}
          >
            <LogRow entry={logs[row.index]} />
          </div>
        ))}
      </div>
    </div>
  )
}

estimateSize: () => 48 podaje początkowe oszacowanie, ale nie ustawia wysokości elementów. ref={virtualizer.measureElement} wraz z data-index pozwala bibliotece zmierzyć wiersze i skorygować ich pozycje. Jeśli wszystkie wiersze mają stałą wysokość, zamiast pomiaru możesz ustawić wysokość zgodną z row.size i zadbać, żeby zawartość mieściła się w tym wymiarze.

Liczba wierszy w DOM zależy teraz głównie od wysokości okna, wysokości wierszy i zapasu overscan. To ogranicza koszt renderowania widocznej części listy, ale filtrowanie lub sortowanie wszystkich rekordów nadal zależy od wielkości zbioru. Przy umiarkowanych listach często wystarczy zwykła paginacja, która również ogranicza liczbę elementów DOM.

Wzorzec 4: Stan w jednym wielkim kontekście

Jeden wielki kontekst React na cały stan aplikacji to problem architektoniczny, który pogarsza INP i naprawia się go rozdzieleniem kontekstów. Kiedy cały stan aplikacji ląduje w pojedynczym kontekście React, każda jego zmiana powiadamia wszystkich konsumentów — także te komponenty, którym zmieniła się jedna, zupełnie obojętna dla nich wartość.

Code
// ŹLE — jeden kontekst na wszystko, zmiana theme przerenderowuje konsumentów cart
const AppContext = createContext<AppState | null>(null)
 
function AppProvider({ children }: { children: React.ReactNode }) {
  const [theme, setTheme] = useState('light')
  const [cart, setCart] = useState<CartItem[]>([])
  const [user, setUser] = useState<User | null>(null)
 
  const value = { theme, setTheme, cart, setCart, user, setUser }
  return <AppContext.Provider value={value}>{children}</AppContext.Provider>
}

Przełączenie motywu uruchamia render konsumenta koszyka, nawet jeśli czyta on tylko cart, ponieważ wszyscy konsumenci subskrybują cały obiekt value. React porównuje poprzednią i nową wartość kontekstu przez Object.is, a tutaj zmiana pola tworzy nowy obiekt. Owinięcie całego value w useMemo nie izoluje koszyka od zmiany theme, bo motyw pozostaje jedną z zależności. Rozdziel konteksty według tego, co faktycznie zmienia się razem, i ustabilizuj ich wartości. Możesz też wydzielić komponenty providerów:

Code
// DOBRZE: osobny kontekst koszyka ze stabilną wartością
const ThemeContext = createContext<ThemeState | null>(null)
const CartContext = createContext<CartState | null>(null)
const UserContext = createContext<UserState | null>(null)
 
function CartProvider({ children }: { children: React.ReactNode }) {
  const [cart, setCart] = useState<CartItem[]>([])
  const value = useMemo(() => ({ cart, setCart }), [cart])
  return <CartContext.Provider value={value}>{children}</CartContext.Provider>
}
// ThemeProvider i UserProvider budujemy analogicznie

Wydzielenie komponentów providerów jest jedną z możliwości. Wszystkie trzy konteksty mogą też dostawać wartości z jednego komponentu, jeśli każdą wartość memoizujesz osobno, np. useMemo(() => ({ cart, setCart }), [cart]). Wtedy zmiana motywu nie zmienia wartości CartContext i nie wywołuje aktualizacji przez ten kontekst. Konsument nadal może się przerenderować wskutek renderu rodzica, zmiany propsów lub własnego stanu, więc oceniaj również sposób składania drzewa komponentów. Przy bardziej złożonym stanie możesz sięgnąć po bibliotekę z selektorami, jak Zustand, aby ograniczyć aktualizacje subskrypcji do wybranego wycinka danych.

Wzorzec 5: Synchroniczna walidacja i formatowanie przy każdym keystroke

Formularze, które przy każdym wciśniętym klawiszu uruchamiają kosztowną walidację, formatowanie albo przeliczenie zależnych pól, mogą pogarszać INP podczas pisania. Dlatego właśnie musisz ograniczyć zakres i częstotliwość walidacji, np. sprawdzając pole przy jego opuszczeniu. Zastosowanie hooka useDeferredValue pozwala nadać renderowi korzystającemu z wyniku niższy priorytet.

Code
// ŹLE — pełna walidacja schematu przy każdym znaku
function CheckoutForm() {
  const [values, setValues] = useState(initialValues)
 
  function handleChange(field: string, value: string) {
    const next = { ...values, [field]: value }
    setValues(next)
    // Walidacja całego formularza na każdy keystroke — zbędna i kosztowna
    validateEntireSchema(next)
  }
 
  return <Form values={values} onChange={handleChange} />
}

W sytuacji, kiedy użytkownik nie potrzebuje pełnej walidacji po każdym znaku, wykonuj ją przy opuszczeniu pola albo próbie wysłania. Gdy chcesz nadal pokazywać błędy podczas pisania, useDeferredValue pozwala oddzielić pilną aktualizację wartości pola od renderu z nowymi wynikami walidacji:

Code
// Pilna aktualizacja pola i walidacja w renderze o niższym priorytecie
function CheckoutForm() {
  const [values, setValues] = useState(initialValues)
  const deferredValues = useDeferredValue(values)
 
  const errors = useMemo(
    () => validateEntireSchema(deferredValues),
    [deferredValues],
  )
 
  function handleChange(field: string, value: string) {
    setValues((prev) => ({ ...prev, [field]: value }))
  }
 
  return <Form values={values} errors={errors} onChange={handleChange} />
}

Pilny render korzysta z nowych values i poprzednich deferredValues, więc useMemo może wtedy pominąć ponowną walidację. React następnie próbuje renderu z nową wartością odroczoną, ale nie gwarantuje, że przeglądarka wcześniej narysuje wpisany znak. validateEntireSchema() nadal jest jednym blokującym wywołaniem, którego React nie przerwie w połowie. Debounce ogranicza częstotliwość walidacji, a onBlur przenosi ją na opuszczenie pola; żadne z nich nie skraca pojedynczego wywołania. Bardzo kosztowną walidację ogranicz do zmienionych pól lub przenieś do Workera. Przy wysyłaniu sprawdź aktualne values, ponieważ odroczone errors mogą jeszcze dotyczyć poprzednich danych.

Biblioteki takie jak React Hook Form domyślnie walidują przy wysłaniu formularza (mode: 'onSubmit'), a walidację przy opuszczeniu pola włączysz trybem onBlur. Po pierwszej próbie wysłania React Hook Form domyślnie ponownie waliduje pola z błędami przy zmianie (reValidateMode: 'onChange').

Hydratacja, skrypty zewnętrzne i długie zadania poza komponentami

Nie każdy zły INP bierze się z kodu komponentów. Długi input delay często oznacza, że w chwili kliknięcia główny wątek był zajęty czymś zupełnie innym, najczęściej hydratacją strony albo skryptami zewnętrznymi.

Hydratacja to moment, w którym React podłącza obsługę zdarzeń do HTML-u wyrenderowanego na serwerze. Dopóki trwa, kliknięcia czekają w kolejce. Od wersji 18 React hydratuje fragmenty owinięte w <Suspense> niezależnie od siebie i w pierwszej kolejności zajmuje się tym, w który użytkownik właśnie kliknął. React Server Components w Next.js idą dalej, bo komponenty serwerowe w ogóle nie trafiają do przeglądarki, więc zostaje mniej JavaScriptu do zhydratowania. Szerzej opisuję to w artykule o tym, gdzie przebiega granica serwer–klient w Next.js.

Skrypty zewnętrzne, czyli analityka, czaty, narzędzia do testów A/B czy tag managery, działają na tym samym głównym wątku co Twoja aplikacja. Ładuj je z opóźnieniem, np. przez next/script ze strategią lazyOnload, i regularnie sprawdzaj, które z nich są jeszcze potrzebne. Jak namierzyć i ograniczyć taki kod, pokazuję w artykule o tym, jak blokować kod psujący LCP i INP w Next.js.

Długie zadania we własnym kodzie można podzielić na krótsze porcje i oddawać między nimi kontrolę przeglądarce. Służy do tego scheduler.yield(), a w przeglądarkach, które go nie obsługują, zwykły setTimeout:

Code
// Oddaje kontrolę przeglądarce, żeby mogła obsłużyć oczekujące interakcje
function yieldToMain(): Promise<void> {
  if (globalThis.scheduler?.yield) return globalThis.scheduler.yield()
  return new Promise((resolve) => setTimeout(resolve, 0))
}
 
async function processInChunks<T>(items: T[], process: (item: T) => void) {
  for (let i = 0; i < items.length; i++) {
    process(items[i])
    if (i % 100 === 99) await yieldToMain()
  }
}

Między kolejnymi porcjami przeglądarka może obsłużyć kliknięcie użytkownika i narysować klatkę, zamiast czekać na koniec całej pętli.

Jak namierzyć wzorzec React, który psuje INP

W realnym projekcie nie zaczynaj od strzelania na ślepo i zacznij od danych terenowych, bo INP mierzy całą wizytę na stronie i tylko realni użytkownicy klikają w miejsca, które są problematyczne. Search Console pokaże grupy podobnych adresów z problemem, a bibliotekę web-vitals od Google podepniesz pod własną analitykę i zbierzesz atrybucję: konkretny element, typ interakcji, czas.

Gdy już wiesz, gdzie szukać, panel Performance w DevTools i sekcja Interactions pozwolą zobaczyć rozbicie pojedynczej interakcji na input delay, przetwarzanie i prezentację. Długi input delay sugeruje zajęty główny wątek, długie przetwarzanie wskazuje na pracę w callbackach zdarzeń, a długa prezentacja wymaga sprawdzenia pracy po ich zakończeniu. W tej ostatniej fazie szukaj renderu Reacta, pozostałego JavaScriptu, przeliczania stylów, układu i rysowania. Sama nazwa fazy nie przesądza o przyczynie.

Najdłuższy etapCo zwykle oznaczaWzorzecRozwiązanie
Input delayGłówny wątek zajęty hydratacją, skryptami zewnętrznymi lub długim zadaniemHydratacja i skrypty zewnętrzneMniej JS do hydratacji, opóźnione skrypty, scheduler.yield()
PrzetwarzanieObliczenia i synchroniczna praca Reacta w callbackach zdarzeńWzorce 1, 2, 4 i 5Mniej pracy w handlerze, memoizacja, podział obliczeń lub Web Worker
Presentation delayRender Reacta i inny JS po callbackach, przeliczanie stylów, layout i rysowanieWzorce 1–5, zależnie od śladuMniej re-renderów i obliczeń, stabilne konteksty, wirtualizacja; niższy priorytet renderowania, jeśli pomaga w pomiarze
Audyt techniczny i optymalizacja SEO.
Audyt techniczny SEO

Często zadawane pytania

Czym różni się INP od FID?

FID, czyli First Input Delay, mierzył wyłącznie opóźnienie pierwszej interakcji i skupiał się wyłącznie na czasie niezbędnym przeglądarce do podjęcia przetwarzania zdarzenia. INP, czyli Interaction to Next Paint, wdrożony w 2024 roku, jest znacznie bardziej rygorystyczny. Rejestruje on wszystkie kliknięcia, dotknięcia i naciśnięcia klawiszy w trakcie całej wizyty na stronie oraz cały ich cykl życia od opóźnienia na wejściu, przez realizację zdarzenia, aż po odrysowanie interfejsu. Dlatego wiele projektów spełniających wymagania FID nie spełnia progów INP.

Jaki INP jest uznawany za dobry?

Dobry wynik INP musi zamknąć się w granicy 200 milisekund na poziomie 75. percentyla. Oznacza to wprost, że co najmniej 75% wizyt na stronie powinno mieć INP nieprzekraczający tej wartości. Wynik między 200 a 500 milisekund Google klasyfikuje jako wymagający poprawy, a wszystko powyżej 500 milisekund jako słaby.

Czy memoizacja (React.memo, useMemo) naprawia INP?

Częściowo. React.memo ogranicza zbędne re-rendery, a useMemo pozwala pominąć powtarzane obliczenia synchroniczne, gdy ich zależności się nie zmieniły. Pomaga to wtedy, gdy ta praca opóźnia następną klatkę. Memoizacja nie skraca jednak pojedynczego koniecznego obliczenia na nowych danych ani nie zmniejsza istniejącego DOM. Długie obliczenia wymagają podziału pracy lub Web Workera, a duże listy często wirtualizacji.

Czy React Compiler rozwiązuje problemy z INP?

Częściowo. React Compiler automatycznie memoizuje komponenty i wartości, więc ogranicza zbędne re-rendery bez ręcznego memo, useMemo i useCallback. Nie skróci jednak ciężkich obliczeń w handlerach, nie zastąpi wirtualizacji długich list i nie naprawi stanu umieszczonego zbyt wysoko w drzewie komponentów. Te decyzje nadal należą do programisty.

Jak zmierzyć INP w aplikacji React?

Dane terenowe pokazuje Google Search Console, która korzysta z raportu CrUX, czyli danych od prawdziwych użytkowników Chrome z ostatnich 28 dni, zgrupowanych w podobne adresy i dostępnych tylko dla stron z odpowiednio dużym ruchem. Dokładniejszy obraz da biblioteka web-vitals podpięta pod własną analitykę. W warunkach laboratoryjnych pamiętaj, że Lighthouse w standardowym trybie nie wykonuje interakcji, więc INP nie zmierzy i podaje jedynie TBT jako przybliżenie. INP lokalnie zmierzysz w panelu Performance w Chrome DevTools albo w trybie timespan Lighthouse. Ostatecznym dowodem na sukces zawsze pozostają dane zgromadzone na podstawie realnych interakcji z oprogramowaniem.

O autorze

Maciej Sala

Maciej Sala — konsultant technologiczny produktów cyfrowych i web developer z bogatym doświadczeniem w marketingu internetowym oraz SEO. Na co dzień pracuje z Reactem, Next.js i TypeScriptem, a ostatnio także z Astro i narzędziami do automatyzacji procesów AI. Sprawnie łączy perspektywę produktową z praktycznym podejściem do kodu. Przez kilka lat był związany z branżą gier wideo jako project manager i game designer. Absolwent historii na Uniwersytecie Jagiellońskim oraz studiów podyplomowych z marketingu internetowego na AGH w Krakowie. Po godzinach trenuje na siłowni, maluje figurki i rozwija własne projekty.

Pomagam przekładać takie tematy na konkretne wdrożenia w frontendzie, SEO, analityce i procesie produktowym.

Skontaktuj się ze mną
LH.pl – Hosting Mango

Biblioteka wiedzy na temat Next.js i React

Czytaj dalej

Zobacz więcej wpisów
Jak poprawić Core Web Vitals i czy to pomaga w Google?

Core Web Vitals pokazują, jak szybko strona wyświetla główną treść, reaguje na działania użytkownika i czy jej układ pozostaje cały czas stabilny. Mimo że Google bierze pod uwagę te metryki przy ustalaniu pozycji, sam „zielony raport” nie zapewnia sukcesu w wynikach wyszukiwania. Najważniejszym czynnikiem zawsze pozostaje merytoryczna i dopasowana do intencji użytkownika treść . W związku z powyższym, by optymalizacja miała sens, trzeba rozpoznać problem w danych, dobrać poprawkę i sprawdzić jej efekty u użytkowników.

Maciej Sala

Maciej Sala

Founder StriveLab

React Compiler: czy useMemo i useCallback są jeszcze potrzebne?

React Compiler odsyła do lamusa jedną z najczęstszych irytacji codziennej pracy z Reactem, czyli ręczne owijanie funkcji i wartości w useMemo oraz useCallback . W dużych aplikacjach dbanie o memoizację pochłaniało godziny, a w małych projektach często dokładano ją na siłę, w złudnej pogoni za „wydajnością". Od kiedy Compiler jest stabilny, ten rytuał w większości przypadków przestał być potrzebny, ale nie zniknął całkowicie i warto wiedzieć, kiedy nadal ma znaczenie.

Maciej Sala

Maciej Sala

Founder StriveLab

JavaScript SEO: kiedy Next.js daje przewagę nad React SPA

Next.js to framework React, który ułatwia uniknięcie głównego ograniczenia aplikacji SPA renderowanych wyłącznie w przeglądarce: kluczowa treść może znaleźć się już w początkowym HTML. Google nie musi wtedy czekać na wykonanie JavaScriptu, żeby ją odkryć. Framework dodaje też Metadata API, optymalizację obrazów i podział kodu, ale korzyść dla Core Web Vitals zależy od sposobu implementacji, ilości kodu klienckiego i infrastruktury.

Maciej Sala

Maciej Sala

Founder StriveLab

LH.pl – Cloud Server 1C4G