React Native Academy · Lekcja

Obsługa stanów ładowania i błędu

Dodaj zmienne stanu isLoading i error, wyświetlaj ActivityIndicator podczas ładowania danych oraz przyjazny dla użytkownika komunikat błędu, gdy żądanie się nie powiedzie.

Obsługa stanów ładowania i błędu to bezpłatna lekcja React Native Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej React Native Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs React Native Academy zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

The Three States of Async Data

Every asynchronous data operation has three possible states: loading (the request is in flight), success (data is available), and error (the request failed). A well-built React Native screen handles all three states explicitly, showing the appropriate UI for each. Ignoring any state leads to blank screens, app crashes, or confusing experiences for users.

Defining Loading and Error State Variables

Add isLoading and error state variables alongside your data state. Initialize isLoading to true since the component begins in a loading state before any data has been fetched. Initialize error to null so it is falsy when there is no error.

const [posts, setPosts] = useState([]);
const [isLoading, setIsLoading] = useState(true);
const [error, setError] = useState(null);

Setting States During Fetch

In the fetch logic, reset the error state at the start of each attempt (so a retry clears the previous error), set the data on success, set the error on failure, and always set isLoading to false in the finally block so the spinner stops regardless of the outcome.

const fetchData = async () => {
  setIsLoading(true);
  setError(null);
  try {
    const response = await axios.get('/posts');
    setPosts(response.data);
  } catch (err) {
    setError(err.message || 'Something went wrong');
  } finally {
    setIsLoading(false);
  }
};

Showing an ActivityIndicator While Loading

Return an ActivityIndicator when isLoading is true. Center it on the screen using a flex container. React Native's ActivityIndicator uses the native platform spinner, matching iOS and Android design conventions automatically.

if (isLoading) {
  return (
    <View style={{ flex: 1, alignItems: 'center', justifyContent: 'center' }}>
      <ActivityIndicator size='large' color='#6200ee' />
      <Text style={{ marginTop: 12, color: '#666' }}>Loading...</Text>
    </View>
  );
}

Showing a User-Friendly Error Message

When error is not null, render an error screen with a clear message and a retry button. Avoid showing raw error objects to users — display a human-readable message instead. The retry button calls the fetch function again, resetting the error and starting a new loading cycle.

if (error) {
  return (
    <View style={{ flex: 1, alignItems: 'center', justifyContent: 'center', padding: 24 }}>
      <Text style={{ fontSize: 18, marginBottom: 8 }}>Oops!</Text>
      <Text style={{ color: '#666', textAlign: 'center', marginBottom: 24 }}>
        {error}
      </Text>
      <Button title='Try Again' onPress={fetchData} />
    </View>
  );
}

Full Component with All Three States

Assemble the complete component: return the loading view when loading, the error view when an error exists, and the data view otherwise. This pattern — early returns for loading and error, then the main content — keeps the JSX clean and readable.

export default function PostsScreen() {
  const [posts, setPosts] = useState([]);
  const [isLoading, setIsLoading] = useState(true);
  const [error, setError] = useState(null);

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

  if (isLoading) return <LoadingView />;
  if (error) return <ErrorView message={error} onRetry={fetchData} />;

  return <FlatList data={posts} renderItem={renderItem} keyExtractor={(p) => String(p.id)} />;
}

Distinguishing Network vs HTTP Errors

Axios throws for both network failures (no internet, timeout) and HTTP errors (4xx, 5xx). Inspect error.response to distinguish them. If error.response exists, the server responded with an error status. If it is undefined, the request never reached the server (network error or timeout).

} catch (err) {
  if (err.response) {
    // Server responded with 4xx/5xx
    const status = err.response.status;
    if (status === 404) setError('Content not found');
    else if (status === 401) setError('Please log in again');
    else setError('Server error: ' + status);
  } else {
    // No response — network/timeout issue
    setError('Network error. Check your connection.');
  }
}

Displaying Inline Errors in Forms

For form submissions, show the error inline near the submit button rather than replacing the whole screen. Users can then correct their input without navigating away. Use a small error Text component with a red color beneath the submit button, and clear it when the user modifies any field.

function LoginForm() {
  const [apiError, setApiError] = useState(null);

  const handleSubmit = async () => {
    setApiError(null);
    try {
      await login(email, password);
    } catch (err) {
      setApiError('Invalid email or password');
    }
  };

  return (
    <View>
      {/* inputs here */}
      {apiError && <Text style={{ color: 'red' }}>{apiError}</Text>}
      <Button title='Sign In' onPress={handleSubmit} />
    </View>
  );
}

Loading State for Button Actions

For actions that take time (submitting a form, deleting an item), show a loading indicator inside the button and disable it while the action is in progress. This prevents duplicate submissions and gives the user immediate feedback that the action is being processed.

function SubmitButton({ onPress }) {
  const [isSubmitting, setIsSubmitting] = useState(false);

  const handlePress = async () => {
    setIsSubmitting(true);
    await onPress();
    setIsSubmitting(false);
  };

  return (
    <TouchableOpacity
      onPress={handlePress}
      disabled={isSubmitting}
      style={[styles.button, isSubmitting && styles.disabledButton]}
    >
      {isSubmitting
        ? <ActivityIndicator color='#fff' />
        : <Text style={styles.buttonText}>Submit</Text>}
    </TouchableOpacity>
  );
}

Skeleton Loading Screens

Instead of a full-screen spinner, consider showing a skeleton screen — placeholder shapes that mimic the layout of the real content. This pattern (used by Facebook, LinkedIn, YouTube) gives a better perceived performance because users see the structure of the content immediately, even before the data loads.

function SkeletonRow() {
  return (
    <View style={styles.skeletonRow}>
      <View style={styles.skeletonAvatar} />
      <View style={{ flex: 1 }}>
        <View style={styles.skeletonLine} />
        <View style={[styles.skeletonLine, { width: '60%' }]} />
      </View>
    </View>
  );
}

if (isLoading) return <FlatList data={[1,2,3,4,5]} renderItem={() => <SkeletonRow />} keyExtractor={(i) => String(i)} />;

Toasts and Snackbars for Non-Critical Errors

Not every error warrants a full error screen. For transient errors that the user can recover from (like a failed background refresh), use a toast notification or snackbar that appears briefly at the bottom of the screen. Libraries like react-native-toast-message provide ready-made toast components for React Native.

import Toast from 'react-native-toast-message';

// On a background refresh failure:
Toast.show({
  type: 'error',
  text1: 'Could not refresh',
  text2: 'Showing cached data',
  visibilityTime: 3000,
});

Quick Check

Test your understanding of handling loading and error states from this lesson.

Lesson Recap

In this lesson you learned: track isLoading and error as separate state variables alongside your data, use ActivityIndicator for full-screen loading and inline error text for form errors, and always call setIsLoading(false) in a finally block so the spinner stops in all cases. Next up we cover POST, PUT, and DELETE requests with Axios.

Często zadawane pytania

Czy lekcja „Obsługa stanów ładowania i błędu” jest bezpłatna?

Tak — pełny tekst „Obsługa stanów ładowania i błędu” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu React Native Academy, przejdź na CoddyKit PRO. Kurs React Native Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Obsługa stanów ładowania i błędu”?

Dodaj zmienne stanu isLoading i error, wyświetlaj ActivityIndicator podczas ładowania danych oraz przyjazny dla użytkownika komunikat błędu, gdy żądanie się nie powiedzie. Ćwiczysz React Native Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć React Native Academy?

Nie wymagamy żadnego doświadczenia. React Native Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Obsługa stanów ładowania i błędu”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji React Native Academy?

Tak. Każda lekcja React Native Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do React Native Academy