React useOptimistic: 掌握全球应用程序的乐观 UI 更新模式

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

function Counter({ initialCount }) {
  const [count, setCount] = useState(initialCount);

  // The useOptimistic hook
  const [optimisticCount, addOptimistic] = useOptimistic(
    count, // The current state (initially the server-fetched count)
    (currentState, newValue) => currentState + newValue // The function to calculate the optimistic state
  );

  const increment = async (amount) => {
    // Optimistically update the UI immediately
    addOptimistic(amount);

    // Simulate an asynchronous operation (e.g., API call)
    await new Promise(resolve => setTimeout(resolve, 1000));

    // In a real app, this would be your API call.
    // If the API call fails, you'd need a way to reset the state.
    // For simplicity here, we assume success and update the actual state.
    setCount(prevCount => prevCount + amount);
  };

  return (
    

      
Server Count: {count}
      
Optimistic Count: {optimisticCount}
       increment(1)}>Increment
    
  );
}

            

              
                Copy
              
            
          

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

function TaskList({ initialTasks }) {
  const [tasks, setTasks] = useState(initialTasks);

  const [optimisticTasks, addOptimisticTask] = useOptimistic(
    tasks,
    (currentTasks, newTaskData) => [
      ...currentTasks,
      { id: Date.now(), text: newTaskData.text, pending: true } // Mark as pending optimistically
    ]
  );

  const addTask = async (taskText) => {
    addOptimisticTask({ text: taskText });
    
    // Simulate API call to add the task
    await new Promise(resolve => setTimeout(resolve, 1500));
    
    // In a real app: 
    // const response = await api.addTask(taskText);
    // if (response.success) {
    //   setTasks(prevTasks => [...prevTasks, { id: response.id, text: taskText, pending: false }]);
    // } else {
    //   // Rollback: Remove the optimistic task
    //   setTasks(prevTasks => prevTasks.filter(task => !task.pending));
    //   console.error('Failed to add task');
    // }
    
    // For this simplified example, we assume success and update the actual state.
    setTasks(prevTasks => prevTasks.map(task => task.pending ? { ...task, pending: false } : task));
  };

  return (
    

      
Tasks
      

        {optimisticTasks.map(task => (
          

            {task.text} {task.pending && '(Saving...)'}
          
        ))}
      
      
       addTask(document.querySelector('input[placeholder="Add new task"]')?.value || '')}>Add Task
    
  );
}

            

              
                Copy
              
            
          

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

function CommentSection({ initialComments }) {
  const [comments, setComments] = useState(initialComments);

  const [optimisticComments, addOptimisticComment] = useOptimistic(
    comments,
    (currentComments, newCommentData) => [
      ...currentComments,
      { id: `optimistic-${Date.now()}`, text: newCommentData.text, author: newCommentData.author, status: 'pending' } 
    ]
  );

  const addComment = async (author, text) => {
    const optimisticComment = { id: `optimistic-${Date.now()}`, text, author, status: 'pending' };
    addOptimisticComment({ text, author });

    try {
      // Simulate API call
      await new Promise(resolve => setTimeout(resolve, 2000));
      
      // Simulate a random failure for demonstration
      if (Math.random() < 0.3) { // 30% chance of failure
        throw new Error('Failed to post comment');
      }

      // Success: Update the actual comments state with a permanent ID and status
      setComments(prevComments => 
        prevComments.map(c => c.id.startsWith('optimistic-') ? { ...c, id: Date.now(), status: 'posted' } : c)
      );
    } catch (error) {
      console.error('Error posting comment:', error);
      // Rollback: Remove the pending comment from the actual state
      setComments(prevComments => 
        prevComments.filter(c => !c.id.startsWith('optimistic-'))
      );
      // Optionally, show an error message to the user
      alert('Failed to post comment. Please try again.');
    }
  };

  return (
    

      
Comments
      

        {optimisticComments.map(comment => (
          

            {comment.author}: {comment.text} {comment.status === 'pending' && '(Sending...)'}
          
        ))}
      
      

      

       addComment(document.getElementById('commentAuthor')?.value, document.getElementById('commentText')?.value)}> 
        Post Comment
      
    
  );
}

            

              
                Copy
              
            
          

            
import React from 'react';
import { useQuery, useMutation, QueryClient } from '@tanstack/react-query';

const queryClient = new QueryClient();

// Mock API function
const fakeApi = {
  getItems: async () => {
    await new Promise(res => setTimeout(res, 500));
    return [{ id: 1, name: 'Global Gadget' }];
  },
  addItem: async (newItem) => {
    await new Promise(res => setTimeout(res, 1500));
    if (Math.random() < 0.2) throw new Error('Network error');
    return { ...newItem, id: Date.now() };
  }
};

function ItemList() {
  const { data: items, isLoading } = useQuery(['items'], fakeApi.getItems);

  const mutation = useMutation({ 
    mutationFn: fakeApi.addItem,
    onMutate: async (newItem) => {
      await queryClient.cancelQueries(['items']);
      const previousItems = queryClient.getQueryData(['items']);
      queryClient.setQueryData(['items'], (old) => [
        ...(old || []),
        { ...newItem, id: 'optimistic-id', isOptimistic: true } // Mark as optimistic
      ]);
      return { previousItems };
    },
    onError: (err, newItem, context) => {
      if (context?.previousItems) {
        queryClient.setQueryData(['items'], context.previousItems);
      }
      console.error('Error adding item:', err);
    },
    onSuccess: (newItem) => {
      queryClient.invalidateQueries(['items']);
    }
  });

  const handleAddItem = () => {
    mutation.mutate({ name: 'New Item' });
  };

  if (isLoading) return 
Loading items...
;

  return (
    

      
Items
      

        {(items || []).map(item => (
          

            {item.name} {item.isOptimistic && '(Saving...)'}
          
        ))}
      
      
        {mutation.isLoading ? 'Adding...' : 'Add Item'}
      
    
  );
}

// In your App component:
// 
//   
// 

            

              
                Copy