Kurs JavaScript i React · Moduł 9: Nowoczesne hooki React

useOptimistic - optymistyczne aktualizacje UI

18 min czytania ·
W tej lekcji4

Wiadomość do bazy na Marsie leci kilka minut, ale załoga nie chce patrzeć na kręcący się wskaźnik. Chce od razu zobaczyć swoją wiadomość na liście, z dopiskiem "wysyłanie". Jeśli transmisja się nie uda, wiadomość ma zniknąć. To właśnie optymistyczna aktualizacja: zakładamy sukces, a w razie porażki wracamy do prawdziwego stanu.

Hook useOptimistic pozwala na natychmiastowe aktualizowanie interfejsu użytkownika przed otrzymaniem odpowiedzi z serwera. To kluczowe narzędzie do tworzenia responsywnych aplikacji, które dają użytkownikowi wrażenie natychmiastowej reakcji.

Podstawy useOptimistic

1. Składnia i podstawowe użycie

Hook przyjmuje prawdziwy stan i funkcję aktualizującą, a zwraca stan optymistyczny oraz funkcję, która go zmienia. Najważniejsza zasada z react.dev: tę funkcję trzeba wywołać wewnątrz Akcji, czyli w startTransition albo w akcji formularza. Poza Akcją React wypisze ostrzeżenie, a zmiana mignie i od razu zniknie. Najpierw logika listy zadań:

import { useOptimistic, useState, startTransition } from 'react';

function TodoList() {
  const [todos, setTodos] = useState([
    { id: 1, text: 'Nauczyć się React', completed: false },
    { id: 2, text: 'Zbudować aplikację', completed: false }
  ]);

  const [optimisticTodos, addOptimisticTodo] = useOptimistic(
    todos,
    // Funkcja aktualizująca stan optymistyczny
    (currentTodos, newTodo) => [...currentTodos, newTodo]
  );

  async function handleAddTodo(text) {
    const newTodo = {
      id: Date.now(),
      text,
      completed: false,
      pending: true // Oznaczenie jako pending
    };

    // Optymistyczna aktualizacja
    addOptimisticTodo(newTodo);

    try {
      // Rzeczywiste wywołanie API
      const response = await fetch('/api/todos', {
        method: 'POST',
        body: JSON.stringify({ text })
      });

      const savedTodo = await response.json();

      // Aktualizacja rzeczywistego stanu
      startTransition(() => {
        setTodos(current => [...current, savedTodo]);
      });
    } catch (error) {
      // W przypadku błędu stan optymistyczny zostanie automatycznie cofnięty
      console.error('Błąd dodawania todo:', error);
    }
  }

Optymistyczne zadanie istnieje tylko tak długo, jak trwa Akcja. Gdy się zakończy, React pokazuje zwykły stan todos. Jeśli zapis się udał, setTodos dodał już prawdziwe zadanie, a jeśli nie, stan jest taki jak przedtem, więc zmiana "cofa się" sama. Aktualizację po await owijamy w kolejne startTransition, tak jak w przykładach z dokumentacji. Oto widok:

  return (
    <div style={{ maxWidth: '500px', margin: '0 auto', padding: '20px' }}>
      <h2>Lista zadań</h2>

      <form
        onSubmit={(e) => {
          e.preventDefault();
          const text = e.target.todo.value;
          if (text) {
            startTransition(() => handleAddTodo(text));
            e.target.reset();
          }
        }}
        style={{ marginBottom: '20px' }}
      >
        <input
          name="todo"
            style={{
            width: '70%',
            padding: '8px',
            marginRight: '10px',
            border: '1px solid #ddd',
            borderRadius: '4px'
          }}
        />
        <button
          type="submit"
          style={{
            padding: '8px 16px',
            backgroundColor: '#007bff',
            color: 'white',
            border: 'none',
            borderRadius: '4px',
            cursor: 'pointer'
          }}
        >
          Dodaj
        </button>
      </form>

      <ul style={{ listStyle: 'none', padding: 0 }}>
        {optimisticTodos.map(todo => (
          <li
            key={todo.id}
            style={{
              padding: '10px',
              marginBottom: '5px',
              backgroundColor: todo.pending ? '#f0f8ff' : '#f8f9fa',
              border: '1px solid #ddd',
              borderRadius: '4px',
              opacity: todo.pending ? 0.7 : 1,
              transition: 'all 0.3s'
            }}
          >
            <input
              type="checkbox"
              checked={todo.completed}
              readOnly
              style={{ marginRight: '10px' }}
            />
            <span style={{
              textDecoration: todo.completed ? 'line-through' : 'none'
            }}>
              {todo.text}
            </span>
            {todo.pending && (
              <span style={{
                marginLeft: '10px',
                color: '#007bff',
                fontSize: '12px'
              }}>
                (zapisywanie...)
              </span>
            )}
          </li>
        ))}
      </ul>
    </div>
  );
}

Formularz wywołuje handleAddTodo wewnątrz startTransition, dzięki czemu optymistyczny wpis z dopiskiem "(zapisywanie...)" zostaje na ekranie aż do odpowiedzi serwera.

2. Optymistyczny przełącznik z obsługą błędów

Przycisk polubienia to klasyczny przypadek: reakcja ma być natychmiastowa, a serwer potwierdza ją w tle. Tutaj funkcja aktualizująca po prostu zwraca nową wartość:

import { useOptimistic, useState, startTransition } from 'react';

function LikeButton({ postId, initialLikes, initialIsLiked }) {
  const [likes, setLikes] = useState(initialLikes);
  const [isLiked, setIsLiked] = useState(initialIsLiked);

  const [optimisticLikes, updateOptimisticLikes] = useOptimistic(
    { count: likes, isLiked },
    (current, optimisticValue) => optimisticValue
  );

  async function handleLikeToggle() {
    const newIsLiked = !optimisticLikes.isLiked;
    const newCount = optimisticLikes.count + (newIsLiked ? 1 : -1);

    // Optymistyczna aktualizacja
    updateOptimisticLikes({
      count: newCount,
      isLiked: newIsLiked
    });

    try {
      const response = await fetch(`/api/posts/${postId}/like`, {
        method: newIsLiked ? 'POST' : 'DELETE'
      });

      if (!response.ok) {
        throw new Error('Błąd aktualizacji');
      }

      const data = await response.json();

      // Aktualizacja rzeczywistego stanu
      setLikes(data.likes);
      setIsLiked(data.isLiked);
    } catch (error) {
      // Stan optymistyczny zostanie automatycznie cofnięty
      alert('Nie udało się zaktualizować polubienia');
    }
  }

  return (
    <button
      onClick={() => startTransition(handleLikeToggle)}
      style={{
        display: 'flex',
        alignItems: 'center',
        gap: '8px',
        padding: '8px 16px',
        backgroundColor: optimisticLikes.isLiked ? '#dc3545' : '#fff',
        color: optimisticLikes.isLiked ? '#fff' : '#dc3545',
        border: '1px solid #dc3545',
        borderRadius: '20px',
        cursor: 'pointer',
        transition: 'all 0.3s',
        fontSize: '16px'
      }}
    >
      <span>{optimisticLikes.isLiked ? 'Polubione' : 'Lubię to'}</span>
      <span>{optimisticLikes.count}</span>
    </button>
  );
}

// Przykład użycia w komponencie posta
function Post({ post }) {
  return (
    <article style={{
      padding: '20px',
      marginBottom: '20px',
      backgroundColor: '#fff',
      borderRadius: '8px',
      boxShadow: '0 2px 4px rgba(0,0,0,0.1)'
    }}>
      <h3>{post.title}</h3>
      <p>{post.content}</p>

      <div style={{
        display: 'flex',
        justifyContent: 'space-between',
        alignItems: 'center',
        marginTop: '15px'
      }}>
        <LikeButton
          postId={post.id}
          initialLikes={post.likes}
          initialIsLiked={post.isLiked}
        />

        <span style={{ color: '#6c757d', fontSize: '14px' }}>
          {new Date(post.createdAt).toLocaleDateString('pl-PL')}
        </span>
      </div>
    </article>
  );
}

Kliknięcie uruchamia handleLikeToggle w startTransition. Gdy serwer zwróci błąd, blok catch pokazuje komunikat, a licznik wraca do wartości z likes, bo prawdziwy stan się nie zmienił.

3. Optymistyczne sortowanie i filtrowanie

Funkcja aktualizująca działa jak reducer: dostaje obecny stan i opis zmiany. Dzięki temu jedno wywołanie obsługuje i checkbox, i zmianę priorytetu:

import { useOptimistic, useState, startTransition } from 'react';

function OptimisticTaskList() {
  const [tasks, setTasks] = useState([
    { id: 1, title: 'Zadanie 1', priority: 'low', completed: false },
    { id: 2, title: 'Zadanie 2', priority: 'high', completed: false },
    { id: 3, title: 'Zadanie 3', priority: 'medium', completed: true }
  ]);

  const [optimisticTasks, updateOptimisticTask] = useOptimistic(
    tasks,
    (currentTasks, { id, updates }) =>
      currentTasks.map(task =>
        task.id === id ? { ...task, ...updates, updating: true } : task
      )
  );

  async function handleTaskUpdate(taskId, updates) {
    // Optymistyczna aktualizacja
    updateOptimisticTask({ id: taskId, updates });

    try {
      const response = await fetch(`/api/tasks/${taskId}`, {
        method: 'PATCH',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(updates)
      });

      const updatedTask = await response.json();

      // Aktualizacja rzeczywistego stanu
      setTasks(current =>
        current.map(task => task.id === taskId ? updatedTask : task)
      );
    } catch (error) {
      console.error('Błąd aktualizacji zadania:', error);
    }
  }

  const priorityColors = {
    low: '#28a745',
    medium: '#ffc107',
    high: '#dc3545'
  };

React uruchamia tę funkcję ponownie, jeśli prawdziwy tasks zmieni się w trakcie Akcji, więc zmiana nakłada się zawsze na aktualne dane. Oto widok ze statystykami:

  return (
    <div style={{ maxWidth: '600px', margin: '0 auto', padding: '20px' }}>
      <h2>Zarządzanie zadaniami</h2>

      <div style={{ marginBottom: '20px' }}>
        <h3>Statystyki:</h3>
        <div style={{ display: 'flex', gap: '20px', fontSize: '14px' }}>
          <span>
            Ukończone: {optimisticTasks.filter(t => t.completed).length}
          </span>
          <span>
            W toku: {optimisticTasks.filter(t => !t.completed).length}
          </span>
          <span>
            Wysokie priorytety: {optimisticTasks.filter(t => t.priority === 'high').length}
          </span>
        </div>
      </div>

      <div style={{ display: 'grid', gap: '10px' }}>
        {optimisticTasks.map(task => (
          <div
            key={task.id}
            style={{
              padding: '15px',
              backgroundColor: task.updating ? '#f0f8ff' : '#fff',
              border: '1px solid #ddd',
              borderRadius: '8px',
              opacity: task.updating ? 0.8 : 1,
              transition: 'all 0.3s'
            }}
          >
            <div style={{
              display: 'flex',
              justifyContent: 'space-between',
              alignItems: 'center'
            }}>
              <div style={{ flex: 1 }}>
                <input
                  type="checkbox"
                  checked={task.completed}
                  onChange={(e) =>
                    startTransition(() => handleTaskUpdate(task.id, { completed: e.target.checked }))
                  }
                  style={{ marginRight: '10px' }}
                />
                <span style={{
                  textDecoration: task.completed ? 'line-through' : 'none',
                  color: task.completed ? '#6c757d' : '#000'
                }}>
                  {task.title}
                </span>
              </div>

              <select
                value={task.priority}
                onChange={(e) =>
                  startTransition(() => handleTaskUpdate(task.id, { priority: e.target.value }))
                }
                style={{
                  padding: '4px 8px',
                  border: `1px solid ${priorityColors[task.priority]}`,
                  borderRadius: '4px',
                  color: priorityColors[task.priority],
                  backgroundColor: 'transparent',
                  cursor: 'pointer'
                }}
              >
                <option value="low">Niski</option>
                <option value="medium">Średni</option>
                <option value="high">Wysoki</option>
              </select>

              {task.updating && (
                <span style={{
                  marginLeft: '10px',
                  color: '#007bff',
                  fontSize: '12px'
                }}>
                  Zapisywanie...
                </span>
              )}
            </div>
          </div>
        ))}
      </div>
    </div>
  );
}

Statystyki liczymy z optimisticTasks, więc liczniki zmieniają się razem z checkboxem, bez czekania na serwer.

Zaawansowane wzorce z useOptimistic

1. Optymistyczne usuwanie z animacją

Tym razem stan optymistyczny nie usuwa elementu, tylko oznacza go flagą deleting, co daje czas na animację:

import { useOptimistic, useState, startTransition } from 'react';

function OptimisticDeleteList() {
  const [items, setItems] = useState([
    { id: 1, name: 'Element 1', createdAt: new Date() },
    { id: 2, name: 'Element 2', createdAt: new Date() },
    { id: 3, name: 'Element 3', createdAt: new Date() }
  ]);

  const [optimisticItems, removeOptimisticItem] = useOptimistic(
    items,
    (currentItems, removedId) =>
      currentItems.map(item =>
        item.id === removedId ? { ...item, deleting: true } : item
      )
  );

  async function handleDelete(itemId) {
    // Optymistyczne oznaczenie jako usuwane
    removeOptimisticItem(itemId);

    // Animacja przed usunięciem
    await new Promise(resolve => setTimeout(resolve, 300));

    try {
      const response = await fetch(`/api/items/${itemId}`, {
        method: 'DELETE'
      });

      if (!response.ok) {
        throw new Error('Błąd usuwania');
      }

      // Rzeczywiste usunięcie ze stanu
      setItems(current => current.filter(item => item.id !== itemId));
    } catch (error) {
      // Cofnięcie optymistycznej zmiany
      alert('Nie udało się usunąć elementu');
    }
  }

  return (
    <div style={{ maxWidth: '500px', margin: '0 auto', padding: '20px' }}>
      <h2>Lista z optymistycznym usuwaniem</h2>

      <div style={{ display: 'grid', gap: '10px' }}>
        {optimisticItems
          .map(item => (
            <div
              key={item.id}
              style={{
                padding: '15px',
                backgroundColor: '#fff',
                border: '1px solid #ddd',
                borderRadius: '8px',
                display: 'flex',
                justifyContent: 'space-between',
                alignItems: 'center',
                opacity: item.deleting ? 0 : 1,
                transform: item.deleting ? 'translateX(-100%)' : 'translateX(0)',
                transition: 'all 0.3s ease-out',
                overflow: 'hidden'
              }}
            >
              <div>
                <h4 style={{ margin: '0 0 5px 0' }}>{item.name}</h4>
                <small style={{ color: '#6c757d' }}>
                  Utworzono: {item.createdAt.toLocaleString('pl-PL')}
                </small>
              </div>

              <button
                onClick={() => startTransition(() => handleDelete(item.id))}
                disabled={item.deleting}
                style={{
                  padding: '5px 10px',
                  backgroundColor: '#dc3545',
                  color: 'white',
                  border: 'none',
                  borderRadius: '4px',
                  cursor: item.deleting ? 'not-allowed' : 'pointer',
                  opacity: item.deleting ? 0.5 : 1
                }}
              >
                {item.deleting ? 'Usuwanie...' : 'Usuń'}
              </button>
            </div>
          ))}
      </div>
    </div>
  );
}

Opóźnienie animacji jest teraz zwykłym await wewnątrz Akcji. Gdyby zapytanie siedziało w setTimeout, Akcja skończyłaby się od razu i flaga deleting zniknęłaby przed usunięciem.

2. Optymistyczna współpraca w czasie rzeczywistym

Edytor współdzielony łączy dwa stany optymistyczne z połączeniem WebSocket. Traktuj go jako szkic architektury:

import { useOptimistic, useState, useEffect, startTransition } from 'react';

function CollaborativeEditor({ documentId, userId }) {
  const [content, setContent] = useState('');
  const [collaborators, setCollaborators] = useState([]);

  const [optimisticContent, updateOptimisticContent] = useOptimistic(
    content,
    (_, newContent) => newContent
  );

  const [optimisticCollaborators, updateOptimisticCollaborators] = useOptimistic(
    collaborators,
    (currentCollaborators, update) => {
      if (update.type === 'cursor') {
        return currentCollaborators.map(c =>
          c.id === update.userId ? { ...c, cursor: update.position } : c
        );
      }
      return currentCollaborators;
    }
  );

  // WebSocket lub inne połączenie real-time
  useEffect(() => {
    const ws = new WebSocket(`ws://localhost:8080/doc/${documentId}`);

    ws.onmessage = (event) => {
      const data = JSON.parse(event.data);

      if (data.type === 'content-update' && data.userId !== userId) {
        setContent(data.content);
      } else if (data.type === 'cursor-update') {
        setCollaborators(data.collaborators);
      }
    };

    return () => ws.close();
  }, [documentId, userId]);

  async function handleContentChange(newContent) {
    // Optymistyczna aktualizacja
    updateOptimisticContent(newContent);

    try {
      await fetch(`/api/documents/${documentId}`, {
        method: 'PATCH',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ content: newContent, userId })
      });

      setContent(newContent);
    } catch (error) {
      console.error('Błąd zapisywania:', error);
    }
  }

  function handleCursorMove(position) {
    updateOptimisticCollaborators({
      type: 'cursor',
      userId,
      position
    });

    // Wyślij aktualizację kursora przez WebSocket
    // ws.send(JSON.stringify({ type: 'cursor', position }));
  }

  return (
    <div style={{ maxWidth: '800px', margin: '0 auto', padding: '20px' }}>
      <h2>Edytor współdzielony</h2>

      <div style={{ marginBottom: '10px' }}>
        <h4>Aktywni użytkownicy:</h4>
        <div style={{ display: 'flex', gap: '10px' }}>
          {optimisticCollaborators.map(collaborator => (
            <div
              key={collaborator.id}
              style={{
                padding: '5px 10px',
                backgroundColor: collaborator.color,
                color: 'white',
                borderRadius: '15px',
                fontSize: '12px'
              }}
            >
              {collaborator.name}
              {collaborator.cursor && (
                <span style={{ marginLeft: '5px' }}>
                  (linia {collaborator.cursor.line})
                </span>
              )}
            </div>
          ))}
        </div>
      </div>

      <textarea
        value={optimisticContent}
        onChange={(e) => startTransition(() => handleContentChange(e.target.value))}
        onSelect={(e) => {
          const position = {
            line: e.target.value.substring(0, e.target.selectionStart).split('\n').length,
            column: e.target.selectionStart
          };
          startTransition(() => handleCursorMove(position));
        }}
        style={{
          width: '100%',
          height: '400px',
          padding: '15px',
          border: '1px solid #ddd',
          borderRadius: '8px',
          fontSize: '16px',
          fontFamily: 'monospace'
        }}
      />

      <div style={{
        marginTop: '10px',
        fontSize: '12px',
        color: '#6c757d'
      }}>
        Ostatnia synchronizacja: {new Date().toLocaleTimeString('pl-PL')}
      </div>
    </div>
  );
}

Kursor reaguje na zdarzenie onSelect, bo React nie ma zdarzenia onSelectionChange dla pola tekstowego. Dwie przestrogi: react.dev odradza sterowanie polem tekstowym przez przejścia, więc treść wpisywaną przez użytkownika lepiej trzymać w zwykłym stanie. Pozycja kursora z kolei nie czeka na serwer, dlatego zwykły useState pasuje do niej lepiej niż stan optymistyczny.

3. Wysyłanie paczkami z kolejką

Czat może wysyłać wiadomości paczkami po pięć. Najpierw kolejka i jej przetwarzanie:

import { useOptimistic, useState, useRef, startTransition } from 'react';

function BatchedUpdatesDemo() {
  const [messages, setMessages] = useState([]);
  const updateQueue = useRef([]);
  const isProcessing = useRef(false);

  const [optimisticMessages, addOptimisticMessage] = useOptimistic(
    messages,
    (currentMessages, newMessage) => [...currentMessages, newMessage]
  );

  async function processBatch() {
    if (isProcessing.current || updateQueue.current.length === 0) return;

    isProcessing.current = true;
    const batch = updateQueue.current.splice(0, 5); // Max 5 na raz

    try {
      const response = await fetch('/api/messages/batch', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ messages: batch })
      });

      const savedMessages = await response.json();

      setMessages(current => [
        ...current,
        ...savedMessages.map(msg => ({ ...msg, sent: true }))
      ]);
    } catch (error) {
      console.error('Błąd wysyłania batch:', error);
      // Przywróć do kolejki
      updateQueue.current.unshift(...batch);
    } finally {
      isProcessing.current = false;
      // Przetwórz następną partię jeśli są
      if (updateQueue.current.length > 0) {
        setTimeout(processBatch, 100);
      }
    }
  }

  async function sendMessage(text) {
    const newMessage = {
      id: Date.now(),
      text,
      timestamp: new Date(),
      sent: false,
      pending: true
    };

    // Optymistyczna aktualizacja
    addOptimisticMessage(newMessage);

    // Dodaj do kolejki
    updateQueue.current.push(newMessage);

    // Rozpocznij przetwarzanie jeśli nie jest aktywne
    await processBatch();
  }

useRef trzyma kolejkę poza stanem, więc jej zmiany nie wywołują renderu. Teraz wysyłanie i widok:

  return (
    <div style={{ maxWidth: '600px', margin: '0 auto', padding: '20px' }}>
      <h2>Chat z batch updates</h2>

      <div style={{
        height: '400px',
        overflowY: 'auto',
        border: '1px solid #ddd',
        borderRadius: '8px',
        padding: '15px',
        marginBottom: '15px',
        backgroundColor: '#f8f9fa'
      }}>
        {optimisticMessages.map(message => (
          <div
            key={message.id}
            style={{
              marginBottom: '10px',
              padding: '10px',
              backgroundColor: message.pending ? '#e3f2fd' : '#fff',
              borderRadius: '8px',
              opacity: message.pending ? 0.8 : 1,
              transition: 'all 0.3s'
            }}
          >
            <div style={{ marginBottom: '5px' }}>{message.text}</div>
            <div style={{
              fontSize: '12px',
              color: '#6c757d',
              display: 'flex',
              justifyContent: 'space-between'
            }}>
              <span>{message.timestamp.toLocaleTimeString('pl-PL')}</span>
              <span>
                {message.pending ? 'Wysyłanie...' : 'Wysłane'}
              </span>
            </div>
          </div>
        ))}
      </div>

      <form
        onSubmit={(e) => {
          e.preventDefault();
          const input = e.target.message;
          if (input.value) {
            startTransition(() => sendMessage(input.value));
            input.value = '';
          }
        }}
        style={{ display: 'flex', gap: '10px' }}
      >
        <input
          name="message"
            style={{
            flex: 1,
            padding: '10px',
            border: '1px solid #ddd',
            borderRadius: '4px'
          }}
        />
        <button
          type="submit"
          style={{
            padding: '10px 20px',
            backgroundColor: '#007bff',
            color: 'white',
            border: 'none',
            borderRadius: '4px',
            cursor: 'pointer'
          }}
        >
          Wyślij
        </button>
      </form>

      <div style={{
        marginTop: '10px',
        fontSize: '12px',
        color: '#6c757d'
      }}>
        W kolejce: {updateQueue.current.length} |
        Przetwarzanie: {isProcessing.current ? 'Tak' : 'Nie'}
      </div>
    </div>
  );
}

sendMessage czeka na processBatch, więc wiadomość zostaje optymistyczna do końca wysyłki. Uwaga: gdy paczka jest już w drodze, processBatch wraca od razu, a kolejna wiadomość może zniknąć przed wysłaniem. Licznik kolejki czyta też ref, więc nie odświeża się sam.

Praktyczne zastosowania useOptimistic

1. System komentarzy z reakcjami

Jeden reducer obsługuje trzy typy zmian: dodanie komentarza, reakcję i odpowiedź. Najpierw logika:

import { useOptimistic, useState, startTransition } from 'react';

function CommentSystem({ postId }) {
  const [comments, setComments] = useState([]);

  const [optimisticComments, updateOptimisticComment] = useOptimistic(
    comments,
    (currentComments, action) => {
      switch (action.type) {
        case 'add':
          return [...currentComments, action.comment];
        case 'react':
          return currentComments.map(comment =>
            comment.id === action.commentId
              ? {
                  ...comment,
                  reactions: {
                    ...comment.reactions,
                    [action.reaction]: (comment.reactions[action.reaction] || 0) + 1
                  },
                  userReacted: action.reaction
                }
              : comment
          );
        case 'reply':
          return currentComments.map(comment =>
            comment.id === action.parentId
              ? {
                  ...comment,
                  replies: [...(comment.replies || []), action.reply]
                }
              : comment
          );
        default:
          return currentComments;
      }
    }
  );

  async function addComment(text) {
    const newComment = {
      id: Date.now(),
      text,
      author: 'Ty',
      timestamp: new Date(),
      reactions: {},
      replies: [],
      pending: true
    };

    updateOptimisticComment({ type: 'add', comment: newComment });

    try {
      const response = await fetch(`/api/posts/${postId}/comments`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ text })
      });

      const savedComment = await response.json();
      setComments(current => [...current, savedComment]);
    } catch (error) {
      console.error('Błąd dodawania komentarza:', error);
    }
  }

  async function reactToComment(commentId, reaction) {
    updateOptimisticComment({
      type: 'react',
      commentId,
      reaction
    });

    try {
      await fetch(`/api/comments/${commentId}/react`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ reaction })
      });

      // Zaktualizuj rzeczywisty stan
      const response = await fetch(`/api/posts/${postId}/comments`);
      const updatedComments = await response.json();
      setComments(updatedComments);
    } catch (error) {
      console.error('Błąd reakcji:', error);
    }
  }

  const reactionLabels = {
    like: 'Lubię',
    love: 'Super',
    laugh: 'Haha',
    wow: 'Wow',
    sad: 'Smutne'
  };

Każda zmiana przechodzi przez updateOptimisticComment z polem type, tak jak akcje w useReducer. Teraz widok:

  return (
    <div style={{ maxWidth: '600px', margin: '0 auto', padding: '20px' }}>
      <h3>Komentarze</h3>

      <form
        onSubmit={(e) => {
          e.preventDefault();
          const text = e.target.comment.value;
          if (text) {
            startTransition(() => addComment(text));
            e.target.reset();
          }
        }}
        style={{ marginBottom: '20px' }}
      >
        <textarea
          name="comment"
            rows="3"
          style={{
            width: '100%',
            padding: '10px',
            border: '1px solid #ddd',
            borderRadius: '4px',
            marginBottom: '10px'
          }}
        />
        <button
          type="submit"
          style={{
            padding: '8px 16px',
            backgroundColor: '#007bff',
            color: 'white',
            border: 'none',
            borderRadius: '4px',
            cursor: 'pointer'
          }}
        >
          Dodaj komentarz
        </button>
      </form>

      <div style={{ display: 'grid', gap: '15px' }}>
        {optimisticComments.map(comment => (
          <div
            key={comment.id}
            style={{
              padding: '15px',
              backgroundColor: comment.pending ? '#f0f8ff' : '#fff',
              border: '1px solid #ddd',
              borderRadius: '8px',
              opacity: comment.pending ? 0.8 : 1
            }}
          >
            <div style={{ marginBottom: '10px' }}>
              <strong>{comment.author}</strong>
              <span style={{
                marginLeft: '10px',
                color: '#6c757d',
                fontSize: '14px'
              }}>
                {comment.timestamp.toLocaleString('pl-PL')}
              </span>
              {comment.pending && (
                <span style={{
                  marginLeft: '10px',
                  color: '#007bff',
                  fontSize: '12px'
                }}>
                  (wysyłanie...)
                </span>
              )}
            </div>

            <p style={{ margin: '10px 0' }}>{comment.text}</p>

            <div style={{ display: 'flex', gap: '10px' }}>
              {Object.entries(reactionLabels).map(([reaction, label]) => (
                <button
                  key={reaction}
                  onClick={() => startTransition(() => reactToComment(comment.id, reaction))}
                  style={{
                    padding: '4px 8px',
                    backgroundColor: comment.userReacted === reaction ? '#e3f2fd' : '#f8f9fa',
                    border: '1px solid #ddd',
                    borderRadius: '15px',
                    cursor: 'pointer',
                    fontSize: '14px',
                    display: 'flex',
                    alignItems: 'center',
                    gap: '4px'
                  }}
                >
                  <span>{label}</span>
                  {comment.reactions[reaction] > 0 && (
                    <span>{comment.reactions[reaction]}</span>
                  )}
                </button>
              ))}
            </div>

            {comment.replies && comment.replies.length > 0 && (
              <div style={{
                marginTop: '15px',
                marginLeft: '20px',
                paddingLeft: '15px',
                borderLeft: '2px solid #e9ecef'
              }}>
                {comment.replies.map(reply => (
                  <div key={reply.id} style={{ marginBottom: '10px' }}>
                    <strong>{reply.author}:</strong> {reply.text}
                  </div>
                ))}
              </div>
            )}
          </div>
        ))}
      </div>
    </div>
  );
}

Przyciski reakcji i formularz uruchamiają funkcje w startTransition, więc liczniki rosną natychmiast.

2. Drag & Drop z optymistycznym sortowaniem

Przeciąganie elementów to kolejny przypadek, w którym użytkownik nie może czekać na serwer:

import { useOptimistic, useState, startTransition } from 'react';

function DragDropList() {
  const [items, setItems] = useState([
    { id: 1, text: 'Element 1', order: 0 },
    { id: 2, text: 'Element 2', order: 1 },
    { id: 3, text: 'Element 3', order: 2 },
    { id: 4, text: 'Element 4', order: 3 }
  ]);

  const [draggedItem, setDraggedItem] = useState(null);

  const [optimisticItems, reorderOptimistic] = useOptimistic(
    items,
    (currentItems, { fromIndex, toIndex }) => {
      const newItems = [...currentItems];
      const [removed] = newItems.splice(fromIndex, 1);
      newItems.splice(toIndex, 0, removed);
      return newItems.map((item, index) => ({ ...item, order: index }));
    }
  );

  async function handleDrop(fromIndex, toIndex) {
    if (fromIndex === toIndex) return;

    // Optymistyczna aktualizacja
    reorderOptimistic({ fromIndex, toIndex });

    try {
      const response = await fetch('/api/items/reorder', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ fromIndex, toIndex })
      });

      const reorderedItems = await response.json();
      setItems(reorderedItems);
    } catch (error) {
      console.error('Błąd zmiany kolejności:', error);
    }
  }

  return (
    <div style={{ maxWidth: '400px', margin: '0 auto', padding: '20px' }}>
      <h2>Lista Drag & Drop</h2>

      <div style={{
        border: '1px solid #ddd',
        borderRadius: '8px',
        overflow: 'hidden'
      }}>
        {optimisticItems.map((item, index) => (
          <div
            key={item.id}
            draggable
            onDragStart={() => setDraggedItem({ item, index })}
            onDragOver={(e) => e.preventDefault()}
            onDrop={() => {
              if (draggedItem) {
                startTransition(() => handleDrop(draggedItem.index, index));
                setDraggedItem(null);
              }
            }}
            style={{
              padding: '15px',
              backgroundColor: '#fff',
              borderBottom: '1px solid #e9ecef',
              cursor: 'move',
              display: 'flex',
              alignItems: 'center',
              transition: 'all 0.3s',
              opacity: draggedItem?.item.id === item.id ? 0.5 : 1
            }}
          >
            <span style={{
              marginRight: '15px',
              fontSize: '20px',
              color: '#6c757d'
            }}>
              ≡
            </span>
            <span style={{ flex: 1 }}>{item.text}</span>
            <span style={{
              color: '#6c757d',
              fontSize: '14px'
            }}>
              #{item.order + 1}
            </span>
          </div>
        ))}
      </div>

      <p style={{
        marginTop: '15px',
        fontSize: '14px',
        color: '#6c757d',
        textAlign: 'center'
      }}>
        Przeciągnij elementy, aby zmienić kolejność
      </p>
    </div>
  );
}

Nowa kolejność pojawia się od razu po upuszczeniu, a serwer tylko ją potwierdza.

Najlepsze praktyki z useOptimistic

1. Struktura danych

Oznaczaj dane optymistyczne, żeby interfejs mógł je wyróżnić:

// DOBRZE - oznaczanie stanu optymistycznego
const optimisticItem = {
  ...originalItem,
  optimistic: true, // lub pending: true
  optimisticId: Date.now() // do identyfikacji
};

// DOBRZE - zachowanie oryginalnych danych
const [optimistic, update] = useOptimistic(
  realData,
  (current, change) => ({
    ...current,
    ...change,
    _original: current // zachowaj oryginał
  })
);

// ŹLE - brak oznaczenia stanu
const badOptimistic = {
  ...originalItem
  // Brak sposobu na odróżnienie od rzeczywistych danych
};

Flaga pending lub optimistic pozwala pokazać "wysyłanie" i zablokować akcje na niepotwierdzonych elementach.

2. Obsługa błędów

Ponawianie z wykładniczym odstępem pasuje do chwilowych awarii sieci:

// Strategia retry z exponential backoff
async function optimisticUpdateWithRetry(action, maxRetries = 3) {
  let lastError;

  for (let i = 0; i < maxRetries; i++) {
    try {
      const result = await action();
      return result;
    } catch (error) {
      lastError = error;

      if (i < maxRetries - 1) {
        // Exponential backoff
        await new Promise(resolve =>
          setTimeout(resolve, Math.pow(2, i) * 1000)
        );
      }
    }
  }

  // Pokaż użytkownikowi błąd
  showErrorNotification('Operacja nie powiodła się. Spróbuj ponownie.');
  throw lastError;
}

Pamiętaj, że stan optymistyczny trwa przez całe ponawianie, bo cała funkcja działa w jednej Akcji.

3. Wydajność

Na koniec dwa wzorce wydajnościowe:

// DOBRZE - batch updates
const [optimistic, batchUpdate] = useOptimistic(
  items,
  (current, updates) => {
    // Przetwórz wiele aktualizacji na raz
    return updates.reduce((acc, update) => {
      // Zastosuj każdą aktualizację
      return applyUpdate(acc, update);
    }, current);
  }
);

// Użycie
function handleMultipleUpdates(updates) {
  batchUpdate(updates); // Jedna aktualizacja zamiast wielu
}

// DOBRZE - memoizacja ciężkich obliczeń
const processedOptimisticData = useMemo(() => {
  return expensiveProcessing(optimisticData);
}, [optimisticData]);

Jedno wywołanie z tablicą zmian daje jeden przebieg reducera zamiast wielu.

Hook useOptimistic to klucz do tworzenia responsywnych aplikacji, które dają użytkownikowi natychmiastową informację zwrotną. Prawidłowe używanie tego hooka może znacząco poprawić postrzeganą wydajność aplikacji.

Moja rada: najprościej jest używać useOptimistic z akcją formularza, bo wtedy React sam owija ją w przejście. W projekcie tego modułu połączysz ten hook z useActionState. Pamiętaj: optymizm na mostku trwa tylko do raportu z Marsa, potem liczy się prawdziwy stan.

Kod do tej lekcji: App.jsx
import { useState, useOptimistic, useTransition } from 'react';

// Symulacja API: opóźnione odpowiedzi serwera
function simulateAPI(action, data) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      // 10% szans na błąd
      if (Math.random() < 0.1) {
        reject(new Error(`Błąd serwera przy: ${action}`));
      } else {
        resolve({ success: true, data });
      }
    }, 1000 + Math.random() * 1500);
  });
}

function MissionCard({ mission, onToggle, onDelete }) {
  return (
    <div style={{
      padding: '14px 16px', marginBottom: '10px',
      background: mission.sending
        ? 'rgba(0, 212, 255, 0.06)'
        : mission.completed
          ? 'rgba(78, 205, 196, 0.08)'
          : 'rgba(255, 255, 255, 0.03)',
      borderRadius: '10px',
      border: `1px solid ${mission.sending ? '#1a3a5c' : mission.completed ? '#2a5c3a' : '#1a2a3c'}`,
      opacity: mission.sending ? 0.7 : 1,
      transition: 'all 0.3s ease',
      display: 'flex', alignItems: 'center', gap: '12px',
    }}>
      <button
        onClick={() => onToggle(mission.id)}
        disabled={mission.sending}
        aria-pressed={mission.completed}
        style={{
          width: '28px', height: '28px', borderRadius: '50%',
          border: `2px solid ${mission.completed ? '#4ecdc4' : '#778da9'}`,
          background: mission.completed ? '#4ecdc4' : 'transparent',
          cursor: mission.sending ? 'default' : 'pointer',
          display: 'flex', alignItems: 'center', justifyContent: 'center',
          color: '#fff', fontSize: '14px', flexShrink: 0,
        }}
      >
        {mission.completed ? '√' : ''}
      </button>

      <div style={{ flex: 1 }}>
        <div style={{
          color: mission.completed ? '#4ecdc4' : '#e0e1dd',
          textDecoration: mission.completed ? 'line-through' : 'none',
          fontSize: '15px', fontWeight: 500,
        }}>
          {mission.name}
        </div>
        <div style={{ color: '#556677', fontSize: '12px', marginTop: '2px' }}>
          {mission.priority}
        </div>
      </div>

      {mission.sending && (
        <span style={{ color: '#00d4ff', fontSize: '11px', fontStyle: 'italic' }}>
          Synchronizacja...
        </span>
      )}

      <button
        onClick={() => onDelete(mission.id)}
        disabled={mission.sending}
        style={{
          padding: '4px 8px', background: 'transparent',
          border: '1px solid #5c1a1a', borderRadius: '4px',
          color: '#ff6b6b', cursor: mission.sending ? 'default' : 'pointer',
          fontSize: '12px',
        }}
      >
        Usuń
      </button>
    </div>
  );
}

export default function App() {
  const [missions, setMissions] = useState([
    { id: 1, name: 'Zbadaj orbitę Marsa', completed: false, priority: 'Wysoki' },
    { id: 2, name: 'Napraw moduł komunikacyjny', completed: true, priority: 'Krytyczny' },
    { id: 3, name: 'Zbierz próbki z Io', completed: false, priority: 'Średni' },
    { id: 4, name: 'Skalibruj teleskop', completed: false, priority: 'Niski' },
  ]);

  const [newMission, setNewMission] = useState('');
  const [error, setError] = useState(null);
  const [isPending, startTransition] = useTransition();

  // useOptimistic - natychmiastowe aktualizacje UI
  const [optimisticMissions, addOptimistic] = useOptimistic(
    missions,
    // Reduktor: (aktualny stan, zmiana optymistyczna) => nowy stan optymistyczny
    (currentMissions, optimisticUpdate) => {
      switch (optimisticUpdate.type) {
        case 'toggle':
          return currentMissions.map(m =>
            m.id === optimisticUpdate.id
              ? { ...m, completed: !m.completed, sending: true }
              : m
          );
        case 'add':
          return [...currentMissions, { ...optimisticUpdate.mission, sending: true }];
        case 'delete':
          return currentMissions.map(m =>
            m.id === optimisticUpdate.id ? { ...m, sending: true } : m
          );
        default:
          return currentMissions;
      }
    }
  );

  // Każda zmiana to Akcja w startTransition: stan optymistyczny trwa, dopóki funkcja asynchroniczna się nie skończy
  function handleToggle(id) {
    setError(null);
    startTransition(async () => {
      addOptimistic({ type: 'toggle', id });
      try {
        await simulateAPI('toggle', { id });
        // Aktualizację po await owijamy w kolejne startTransition, jak radzi react.dev
        startTransition(() => {
          setMissions(prev =>
            prev.map(m => m.id === id ? { ...m, completed: !m.completed } : m)
          );
        });
      } catch (err) {
        // Błąd: nic nie zmieniamy, stan optymistyczny zniknie sam po zakończeniu Akcji
        setError(`Nie udało się zmienić statusu misji (ID: ${id})`);
      }
    });
  }

  function handleAdd(e) {
    e.preventDefault();
    const name = newMission.trim();
    if (!name) return;
    setError(null);
    setNewMission('');

    const tempMission = { id: Date.now(), name, completed: false, priority: 'Średni' };
    startTransition(async () => {
      addOptimistic({ type: 'add', mission: tempMission });
      try {
        await simulateAPI('add', tempMission);
        startTransition(() => {
          setMissions(prev => [...prev, tempMission]);
        });
      } catch (err) {
        setError('Nie udało się dodać misji');
      }
    });
  }

  function handleDelete(id) {
    setError(null);
    startTransition(async () => {
      addOptimistic({ type: 'delete', id });
      try {
        await simulateAPI('delete', { id });
        startTransition(() => {
          setMissions(prev => prev.filter(m => m.id !== id));
        });
      } catch (err) {
        setError(`Nie udało się usunąć misji (ID: ${id})`);
      }
    });
  }

  const completed = optimisticMissions.filter(m => m.completed).length;
  const total = optimisticMissions.length;

  return (
    <div style={{
      minHeight: '100vh',
      background: 'linear-gradient(135deg, #0a0e27 0%, #1a1a3e 100%)',
      padding: '24px', fontFamily: 'monospace',
    }}>
      <h1 style={{ color: '#00d4ff', textAlign: 'center', marginBottom: '4px' }}>
        useOptimistic - Misje kosmiczne
      </h1>
      <p style={{ color: '#778da9', textAlign: 'center', marginBottom: '24px', fontSize: '13px' }}>
        Zmiany widoczne natychmiast, synchronizacja w tle
      </p>

      <div style={{ maxWidth: '550px', margin: '0 auto' }}>
        <div style={{
          marginBottom: '20px', padding: '14px',
          background: 'rgba(0, 212, 255, 0.06)', borderRadius: '10px',
        }}>
          <div style={{
            display: 'flex', justifyContent: 'space-between',
            marginBottom: '8px', fontSize: '13px', color: '#c0c8d0',
          }}>
            <span>Postęp misji {isPending && <em style={{ color: '#00d4ff' }}>(trwa synchronizacja)</em>}</span>
            <span>{completed}/{total} ukończonych</span>
          </div>
          <div style={{
            height: '8px', background: '#1a2a3c', borderRadius: '4px', overflow: 'hidden',
          }}>
            <div style={{
              height: '100%', width: `${total > 0 ? (completed / total) * 100 : 0}%`,
              background: 'linear-gradient(90deg, #00d4ff, #4ecdc4)',
              borderRadius: '4px', transition: 'width 0.3s ease',
            }} />
          </div>
        </div>

        <form onSubmit={handleAdd} style={{
          display: 'flex', gap: '8px', marginBottom: '20px',
        }}>
          <input
            value={newMission}
            onChange={e => setNewMission(e.target.value)}
            placeholder="Nowa misja..."
            style={{
              flex: 1, padding: '10px 14px', background: '#0d1b2a',
              border: '1px solid #1a3a5c', borderRadius: '8px',
              color: '#e0e1dd', fontSize: '14px',
            }}
          />
          <button type="submit" style={{
            padding: '10px 20px', background: '#1a3a5c',
            border: 'none', borderRadius: '8px', color: '#00d4ff',
            cursor: 'pointer', fontSize: '13px', whiteSpace: 'nowrap',
          }}>
            + Dodaj
          </button>
        </form>

        {error && (
          <div role="alert" style={{
            padding: '10px 14px', marginBottom: '12px',
            background: 'rgba(255, 107, 107, 0.1)', borderRadius: '8px',
            border: '1px solid #5c1a1a', color: '#ff6b6b', fontSize: '13px',
          }}>
            {error}
          </div>
        )}

        {optimisticMissions.map(mission => (
          <MissionCard
            key={mission.id}
            mission={mission}
            onToggle={handleToggle}
            onDelete={handleDelete}
          />
        ))}

        <div style={{
          marginTop: '20px', padding: '14px',
          background: 'rgba(255, 215, 0, 0.06)', borderRadius: '10px',
          fontSize: '12px', color: '#c0c8d0', lineHeight: '1.7',
        }}>
          <strong style={{ color: '#ffd700' }}>Jak działa useOptimistic:</strong>
          <ul style={{ margin: '8px 0', paddingLeft: '18px' }}>
            <li>UI aktualizuje się natychmiast (optymistycznie)</li>
            <li>W tle trwa synchronizacja z serwerem (1-2,5 s)</li>
            <li>Przy błędzie (10% szans) stan optymistyczny znika i wraca prawdziwy stan</li>
            <li>Wskaźnik "Synchronizacja..." informuje o trwającej Akcji</li>
          </ul>
        </div>
      </div>
    </div>
  );
}

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Do czego służy hook useTransition w React?

  2. 2. Co się dzieje z optymistyczną aktualizacją UI (useOptimistic), gdy żądanie do serwera zwróci błąd?

To 2 z 9 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w pionie

    Ułóż kod komponentu, który łączy etykietę z polem przez useId:

  • Układanie w pionie

    Ułóż poprawną składnię użycia useTransition:

  • Edytor kodu

    Czat z bazą Luna wysyła wiadomości przez akcję formularza sendMessage. Łącze odpowiada po 0,6 s, a wiadomość zaczynająca się od ! udaje zakłócenia i kończy się błędem. Uzupełnij luki: ___BLANK1___ to hook Reacta 19, który tworzy stan optymistyczny z prawdziwej listy messages i funkcji dopisującej wiadomość, ___BLANK2___ to funkcja, którą pokazujesz wiadomość od razu, zanim baza odpowie, a ___BLANK3___ to lista, którą wyświetlasz w <ul>. Wysłana wiadomość ma się pojawić natychmiast z dopiskiem o wysyłaniu, po potwierdzeniu zostać bez dopisku, a przy błędzie zniknąć i zostawić komunikat.

  • Układanie w pionie

    Uporządkuj etapy jednego cyklu renderowania w React:

  • Układanie w pionie

    Uporządkuj kroki ładowania danych za pomocą hooka use() i Suspense:

  • Klikanie w kolejności

    Ułóż składnię hooka useCallback do stabilizacji referencji funkcji:

  • Układanie w pionie

    Od czego zaczynasz optymalizację wydajności? Ułóż etapy: pierwszy krok jest stały, a kolejność technik po nim zależy od tego, co pokaże pomiar.

  • Układanie w poziomie

    Ułóż składnię destrukturyzacji hooka useOptimistic:

  • Układanie w pionie

    Uporządkuj etapy pipeline optymalizacji buildu od analizy do dostarczenia:

  • Edytor kodu

    Analizator paczki (np. rollup-plugin-visualizer w Vite) zapisał rozmiary modułów aplikacji po kompresji. Uzupełnij raport: ___BLANK1___ to rozmiar pojedynczego modułu (pole obiektu item), który reduce dodaje do sumy, ___BLANK2___ to wyrażenie porównujące, które ustawia moduły od największego do najmniejszego, a ___BLANK3___ to warunek prawdziwy dla modułu większego niż budżet BUDGET. Raport ma pokazać łączny rozmiar 742 kB, listę od star-map (310 kB) do navigation (24 kB), a po zaznaczeniu pola tylko trzy moduły powyżej 100 kB, czyli kandydatów do wydzielenia przez lazy().

  • Klikanie w kolejności

    Ułóż składnię komponentu Profiler do mierzenia wydajności (atrybut id przed onRender):

  • Układanie w pionie

    Uporządkuj kroki diagnozowania wydajności za pomocą React Profiler:

  • Edytor kodu

    Galeria pokazuje zdjęcia trzech planet. Każde zdjęcie ma małą, rozmytą miniaturę widoczną od razu i pełny obraz, który pojawia się dopiero po załadowaniu. Uzupełnij komponent PlanetImage: ___BLANK1___ to wartość atrybutu loading, dzięki której przeglądarka pobierze pełny obraz dopiero, gdy zbliży się on do ekranu, ___BLANK2___ to status ustawiany po zdarzeniu load (miniatura znika, a zdjęcie staje się widoczne), a ___BLANK3___ to wywołanie, które po zdarzeniu error ustawia status 'error'. Każde zdjęcie ma własny stan, a błąd pokazuje komunikat z nazwą planety.

  • Układanie w poziomie

    Ułóż składnię elementu img z atrybutem lazy loading:

  • Edytor kodu

    Wykres TelemetryChart renderuje setki słupków, a przycisk dokłada kolejne. Zmierz jego rendery komponentem Profiler: ___BLANK1___ to trzeci parametr callbacku, czyli czas renderu w milisekundach (ta nazwa jest już użyta w ciele funkcji), ___BLANK2___ to komponent Reacta, który mierzy rendery swojego poddrzewa, a ___BLANK3___ to funkcja przekazana do jego atrybutu onRender. Po zamontowaniu w konsoli ma się pojawić wpis z fazą mount, a po kliknięciu przycisku wpis z fazą update.

  • Klikanie w kolejności

    Ułóż deklarację komponentu lazy-loaded z React.lazy:

  • Układanie w pionie

    Uporządkuj implementację lazy loading:

  • Edytor kodu

    Kalkulator skoku nadświetlnego liczy zużycie paliwa w wątku roboczym, żeby interfejs nie zamarzał. Wątek ma API Web Workera: postMessage wysyła dane, onmessage odbiera wynik, a terminate zatrzymuje wątek (w podglądzie funkcja createWorker go udaje). Uzupełnij luki: ___BLANK1___ to pole obiektu zdarzenia, w którym przychodzi wynik, ___BLANK2___ to metoda, którą sprzątanie efektu zatrzymuje wątek, a ___BLANK3___ to metoda, którą kliknięcie wysyła dystans do wątku. Wątek ma powstać raz po zamontowaniu, przycisk ma być zablokowany do czasu odpowiedzi, a wynik ma pojawić się na ekranie.

  • Klikanie w kolejności

    Uporządkuj setup Performance Observer:

  • Edytor kodu

    Funkcje cacheFirst, networkFirst i pickStrategy trafią do pliku sw.js i obsłużą zdarzenie fetch w Service Workerze. Pliki statyczne mają działać w strategii cache-first (najpierw kopia z cache, sieć tylko przy braku kopii), a dane z /api/ w strategii network-first (najpierw świeża odpowiedź z sieci, kopia z cache tylko bez łączności). Uzupełnij luki: ___BLANK1___ to metoda cache, która szuka zapisanej odpowiedzi, ___BLANK2___ to metoda cache, która zapisuje odpowiedź, a ___BLANK3___ to funkcja strategii, którą pickStrategy zwraca dla adresów /api/. Panel w podglądzie pozwala wyłączyć sieć i sprawdzić, skąd przychodzą odpowiedzi.

  • Edytor kodu

    Formularz raportu dla Centrum Kontroli korzysta z useActionState, a przycisk wysyłania jest osobnym komponentem SubmitButton, który sam ma wiedzieć, że formularz jest w trakcie wysyłki. Uzupełnij luki: ___BLANK1___ to pole zwracane przez hook, które ma wartość true w czasie wysyłki, ___BLANK2___ to hook z react-dom, który odczytuje stan formularza, w którym jest wyrenderowany komponent, ___BLANK3___ to komponent przycisku wstawiony do formularza, a ___BLANK4___ to status, który akcja zwraca dla za krótkiego raportu. Raport krótszy niż 10 znaków ma pokazać błąd, dłuższy potwierdzenie, a w czasie transmisji przycisk ma być zablokowany i zmienić napis.

  1. PytanieuseTransition dla niepilnych aktualizacji
  2. Ułóż w kolejnościSkładnia useId dla dostępności
  3. Ułóż w kolejnościSkładnia useTransition
  4. Zadanie z kodemPraktyka: Optymistyczne aktualizacje UI
  5. Ułóż w kolejnościCykl renderowania React
  6. Ułóż w kolejnościPrzepływ use() z Suspense
  7. PytanieuseOptimistic - rollback na błąd
  8. Kliknij w kolejnościSkładnia useCallback
  9. Ułóż w kolejnościEtapy optymalizacji wydajności
  10. PytanieHook use() a useContext
  11. PytanieConcurrent rendering w React
  12. Ułóż w kolejnościSkładnia useOptimistic
  13. PytanieuseDeferredValue a useTransition
  14. Ułóż w kolejnościPipeline optymalizacji budowania
  15. PytanieHooki React 18+
  16. Zadanie z kodemPraktyka: Analiza paczki (bundle)
  17. Kliknij w kolejnościSkładnia komponentu Profiler
  18. PytanieWpływ importów na rozmiar paczki
  19. Ułóż w kolejnościWorkflow React Profiler
  20. Zadanie z kodemPraktyka: Lazy loading obrazów
  21. Ułóż w kolejnościSkładnia lazy loading obrazu
  22. Zadanie z kodemPraktyka: React Profiler
  23. Kliknij w kolejnościSkładnia React.lazy
  24. Ułóż w kolejnościImplementacja lazy loading z Suspense
  25. Zadanie z kodemPraktyka: Web Workers
  26. PytanieDynamiczny import w React
  27. Kliknij w kolejnościKonfiguracja monitorowania wydajności
  28. Zadanie z kodemPraktyka: Service Worker
  29. PytanieAutomatic batching a setTimeout
  30. Zadanie z kodemPraktyka: useActionState i useFormStatus

Przydatne artykuły