Kurs JavaScript i React · Moduł 3: Stan i zdarzenia

Przepływ danych

9 min czytania ·
W tej lekcji7

W kosmicznej podróży przez React, zrozumienie przepływu danych jest jak poznanie map gwiezdnych systemów - kluczowe dla bezpiecznej i efektywnej żeglugi. React opiera się na jednokierunkowym przepływie danych, który zapewnia przewidywalność i ułatwia debugowanie aplikacji.

Jednokierunkowy przepływ danych

React wykorzystuje jednokierunkowy przepływ danych (z góry na dół). Oznacza to, że dane przepływają tylko w jednym kierunku: od komponentów nadrzędnych (rodziców) do komponentów podrzędnych (dzieci).

Wyobraź sobie strukturę swojej aplikacji jak hierarchię dowodzenia w misji kosmicznej:

  • Centrum dowodzenia (komponent najwyższego poziomu) wysyła instrukcje i dane do różnych modułów
  • Każdy moduł może przekazać te dane dalej do swoich podmodułów
  • Podmoduły nie mogą bezpośrednio modyfikować danych otrzymanych od modułów nadrzędnych
  • Aby zmienić dane, podmoduły muszą "raportować" zmiany do modułów nadrzędnych, które mogą zaktualizować dane i przekazać je z powrotem

Zalety jednokierunkowego przepływu danych

  1. Przewidywalność - łatwiej zrozumieć skąd pochodzą dane i jak się zmieniają
  2. Łatwiejsze debugowanie - problemy z danymi można śledzić "pod prąd" do źródła
  3. Lepsza wydajność - React może zoptymalizować aktualizacje komponentów
  4. Mniejsza złożoność - każdy komponent ma jasno określoną rolę w przepływie danych

Props jako mechanizm przekazywania danych w dół

Głównym mechanizmem przekazywania danych od rodzica do dzieci są props (właściwości):

// Komponent rodzica
function MissionControl() {
  const missionData = {
    name: "Apollo 11",
    destination: "Księżyc",
    crew: ["Neil Armstrong", "Buzz Aldrin", "Michael Collins"],
    status: "W trakcie"
  };

  return (
    <div className="mission-control">
      <h1>Centrum Kontroli Misji</h1>
      <MissionInfo
        name={missionData.name}
        destination={missionData.destination}
        status={missionData.status}
      />
      <CrewDisplay crew={missionData.crew} />
    </div>
  );
}

// Komponent dziecka
function MissionInfo({ name, destination, status }) {
  return (
    <div className="mission-info">
      <h2>{name}</h2>
      <p>Cel: {destination}</p>
      <p>Status: {status}</p>
    </div>
  );
}

// Inny komponent dziecka
function CrewDisplay({ crew }) {
  return (
    <div className="crew-display">
      <h2>Załoga</h2>
      <ul>
        {crew.map((member, index) => (
          <li key={index}>{member}</li>
        ))}
      </ul>
    </div>
  );
}

W tym przykładzie:

  • MissionControl jest komponentem rodzica, który zawiera dane misji
  • Przekazuje te dane w dół do komponentów MissionInfo i CrewDisplay poprzez props
  • Komponenty dzieci odbierają te dane i renderują je, ale nie mogą ich bezpośrednio modyfikować

Komunikacja w górę - jak dzieci komunikują się z rodzicami

Skoro dane płyną tylko w dół, jak komponenty niższego poziomu mogą komunikować się z komponentami wyższego poziomu? Rozwiązaniem jest technika polegająca na przekazywaniu funkcji w dół jako props, które komponenty dzieci mogą wywołać, aby "zgłosić" zmiany do rodzica.

function MissionControl() {
  const [missionStatus, setMissionStatus] = useState("Przygotowanie");

  // Ta funkcja będzie przekazana dziecku
  const updateStatus = (newStatus) => {
    setMissionStatus(newStatus);
    console.log(`Status misji zaktualizowany na: ${newStatus}`);
  };

  return (
    <div className="mission-control">
      <h1>Centrum Kontroli Misji</h1>
      <p>Aktualny status: {missionStatus}</p>

      {/* Przekazujemy funkcję updateStatus jako prop do StatusControls */}
      <StatusControls
        currentStatus={missionStatus}
        onStatusChange={updateStatus}
      />
    </div>
  );
}

function StatusControls({ currentStatus, onStatusChange }) {
  return (
    <div className="status-controls">
      <h2>Kontrola statusu</h2>

      <button
        onClick={() => onStatusChange("Odliczanie")}
        disabled={currentStatus === "Odliczanie"}
      >
        Rozpocznij odliczanie
      </button>

      <button
        onClick={() => onStatusChange("Start")}
        disabled={currentStatus === "Start" || currentStatus !== "Odliczanie"}
      >
        Inicjuj start
      </button>

      <button
        onClick={() => onStatusChange("Orbita")}
        disabled={currentStatus === "Orbita" || currentStatus !== "Start"}
      >
        Potwierdź osiągnięcie orbity
      </button>

      <button
        onClick={() => onStatusChange("Przerwano")}
        disabled={currentStatus === "Przerwano" || currentStatus === "Orbita"}
      >
        Przerwij misję
      </button>
    </div>
  );
}

W tym przykładzie:

  1. MissionControl (rodzic) definiuje funkcję updateStatus
  2. Przekazuje tę funkcję jako prop onStatusChange do komponentu StatusControls (dziecko)
  3. StatusControls wywołuje tę funkcję z nową wartością, gdy użytkownik klika przycisk
  4. Po wywołaniu, funkcja aktualizuje stan w komponencie rodzica, co prowadzi do ponownego renderowania
  5. Zaktualizowane dane (nowy status) przepływają z powrotem w dół do dzieci poprzez props

Ten wzorzec pozwala na zachowanie jednokierunkowego przepływu danych, mimo że komponenty niższego poziomu mogą wpływać na dane w komponentach wyższego poziomu.

Lifting state up (wynoszenie stanu w górę)

"Lifting state up" to ważna koncepcja w React, polegająca na przeniesieniu stanu z komponentów potomnych do najbliższego wspólnego przodka, który potrzebuje dostępu do tych danych. Ta technika jest kluczowa dla zachowania jednokierunkowego przepływu danych.

Rozważmy przykład z modułami statku kosmicznego, które muszą współdzielić dane:

function SpaceshipDashboard() {
  // Stan został "wyniesiony w górę" do wspólnego rodzica
  const [power, setPower] = useState(100);
  const [shields, setShields] = useState(75);
  const [weapons, setWeapons] = useState(0);

  // Funkcje do aktualizacji stanu
  const adjustPower = (system, amount) => {
    if (system === 'shields') {
      setShields(prev => Math.min(100, Math.max(0, prev + amount)));
      setPower(prev => Math.max(0, prev - amount));
    } else if (system === 'weapons') {
      setWeapons(prev => Math.min(100, Math.max(0, prev + amount)));
      setPower(prev => Math.max(0, prev - amount));
    }
  };

  return (
    <div className="spaceship-dashboard">
      <h1>Panel kontrolny statku kosmicznego</h1>

      <PowerDisplay powerLevel={power} />

      <div className="systems">
        <ShieldSystem
          shieldLevel={shields}
          onAdjustPower={amount => adjustPower('shields', amount)}
        />

        <WeaponSystem
          weaponCharge={weapons}
          onAdjustPower={amount => adjustPower('weapons', amount)}
        />
      </div>
    </div>
  );
}

function PowerDisplay({ powerLevel }) {
  return (
    <div className="power-display">
      <h2>Rezerwa mocy: {powerLevel}%</h2>
      <div className="power-bar" style={{ width: `${powerLevel}%` }}></div>
    </div>
  );
}

function ShieldSystem({ shieldLevel, onAdjustPower }) {
  return (
    <div className="system-panel shields">
      <h2>Tarcze: {shieldLevel}%</h2>
      <div className="shield-bar" style={{ height: `${shieldLevel}%` }}></div>

      <div className="controls">
        <button onClick={() => onAdjustPower(10)} disabled={shieldLevel >= 100}>
          + Zwiększ moc tarcz
        </button>
        <button onClick={() => onAdjustPower(-10)} disabled={shieldLevel <= 0}>
          - Zmniejsz moc tarcz
        </button>
      </div>
    </div>
  );
}

function WeaponSystem({ weaponCharge, onAdjustPower }) {
  return (
    <div className="system-panel weapons">
      <h2>Ładowanie broni: {weaponCharge}%</h2>
      <div className="weapon-bar" style={{ height: `${weaponCharge}%` }}></div>

      <div className="controls">
        <button onClick={() => onAdjustPower(25)} disabled={weaponCharge >= 100}>
          Ładuj broń
        </button>
        <button onClick={() => onAdjustPower(-25)} disabled={weaponCharge <= 0}>
          Rozładuj broń
        </button>
      </div>
    </div>
  );
}

W tym przykładzie:

  1. Stan dotyczący mocy, tarcz i broni jest przechowywany w komponencie nadrzędnym SpaceshipDashboard
  2. Komponenty ShieldSystem i WeaponSystem otrzymują tylko dane, które potrzebują oraz funkcje do aktualizacji tych danych
  3. Gdy jeden system wykorzystuje moc, wpływa to na dostępną moc dla innych systemów
  4. Logika współdzielenia zasobów jest zarządzana centralnie przez komponent nadrzędny

Ta technika jest szczególnie przydatna, gdy:

  • Wiele komponentów potrzebuje tych samych danych
  • Dane w jednym komponencie wpływają na dane w innych komponentach
  • Komponenty muszą się synchronizować

Komponenty kontrolowane i niekontrolowane

W React, szczególnie w kontekście formularzy, istnieją dwa podejścia do zarządzania danymi wejściowymi: komponenty kontrolowane i niekontrolowane.

Komponenty kontrolowane

W komponentach kontrolowanych, dane formularza są zarządzane przez stan React. Każda zmiana wprowadzona przez użytkownika przechodzi przez React:

function ControlledMissionForm() {
  const [formData, setFormData] = useState({
    missionName: '',
    duration: '',
    crew: ''
  });

  const handleChange = (e) => {
    setFormData({
      ...formData,
      [e.target.name]: e.target.value
    });
  };

  const handleSubmit = (e) => {
    e.preventDefault();
    console.log('Dane misji:', formData);
    // Logika wysyłania danych...
  };

  return (
    <form onSubmit={handleSubmit}>
      <div>
        <label>
          Nazwa misji:
          <input
            type="text"
            name="missionName"
            value={formData.missionName}
            onChange={handleChange}
          />
        </label>
      </div>

      <div>
        <label>
          Czas trwania (dni):
          <input
            type="number"
            name="duration"
            value={formData.duration}
            onChange={handleChange}
          />
        </label>
      </div>

      <div>
        <label>
          Liczba załogantów:
          <input
            type="number"
            name="crew"
            value={formData.crew}
            onChange={handleChange}
          />
        </label>
      </div>

      <button type="submit">Zaplanuj misję</button>
    </form>
  );
}

Zalety komponentów kontrolowanych:

  • Pełna kontrola nad stanem i walidacją w czasie rzeczywistym
  • Możliwość natychmiastowej reakcji na zmiany (np. dynamiczna walidacja)
  • Łatwość w manipulowaniu i transformowaniu danych wejściowych

Komponenty niekontrolowane

Komponenty niekontrolowane pozwalają samemu DOM zarządzać stanem formularza:

function UncontrolledMissionForm() {
  // Referencje do elementów DOM
  const missionNameRef = useRef();
  const durationRef = useRef();
  const crewRef = useRef();

  const handleSubmit = (e) => {
    e.preventDefault();

    const formData = {
      missionName: missionNameRef.current.value,
      duration: durationRef.current.value,
      crew: crewRef.current.value
    };

    console.log('Dane misji:', formData);
    // Logika wysyłania danych...
  };

  return (
    <form onSubmit={handleSubmit}>
      <div>
        <label>
          Nazwa misji:
          <input
            type="text"
            name="missionName"
            ref={missionNameRef}
            defaultValue="Misja Mars"
          />
        </label>
      </div>

      <div>
        <label>
          Czas trwania (dni):
          <input
            type="number"
            name="duration"
            ref={durationRef}
            defaultValue="90"
          />
        </label>
      </div>

      <div>
        <label>
          Liczba załogantów:
          <input
            type="number"
            name="crew"
            ref={crewRef}
            defaultValue="4"
          />
        </label>
      </div>

      <button type="submit">Zaplanuj misję</button>
    </form>
  );
}

Zalety komponentów niekontrolowanych:

  • Mniejsza ilość kodu dla prostych formularzy
  • Mniej renderowań (lepsza wydajność w niektórych przypadkach)
  • Łatwiejsza integracja z bibliotekami zewnętrznymi

W większości przypadków, zaleca się używanie komponentów kontrolowanych, ponieważ zapewniają one większą kontrolę i są bardziej zgodne z filozofią Reacta. Jednak w niektórych scenariuszach (np. przesyłanie plików, integracja z bibliotekami zewnętrznymi) komponenty niekontrolowane mogą być bardziej praktyczne.

Przepływ danych w większych aplikacjach

W miarę rozrastania się aplikacji, przepływ danych może stać się bardziej złożony. W takich przypadkach warto rozważyć:

1. Kontekst (Context API)

Dla danych, które są potrzebne w wielu miejscach w aplikacji, można użyć Context API, aby uniknąć tzw. "props drilling" (przekazywania props przez wiele poziomów komponentów):

// Tworzenie kontekstu
const MissionContext = React.createContext();

// Komponent Provider na wysokim poziomie
function MissionProvider({ children }) {
  const [missionData, setMissionData] = useState({
    name: "Artemis",
    phase: "Przygotowanie",
    crew: ["Anna", "Jan", "Maria", "Piotr"],
    launchDate: "2025-07-20"
  });

  const updateMission = (updates) => {
    setMissionData(prev => ({
      ...prev,
      ...updates
    }));
  };

  return (
    <MissionContext.Provider value={{ missionData, updateMission }}>
      {children}
    </MissionContext.Provider>
  );
}

// Użycie w głęboko zagnieżdżonym komponencie
function DeepNestedComponent() {
  const { missionData, updateMission } = useContext(MissionContext);

  return (
    <div>
      <h3>Faza misji: {missionData.phase}</h3>
      <button onClick={() => updateMission({ phase: "Odliczanie" })}>
        Rozpocznij odliczanie
      </button>
    </div>
  );
}

// Struktura aplikacji
function App() {
  return (
    <MissionProvider>
      <div className="app">
        <Header />
        <MainDashboard />
        <Footer />
      </div>
    </MissionProvider>
  );
}

2. Zarządzanie stanem globalnym

Dla jeszcze bardziej złożonych aplikacji, można rozważyć biblioteki zarządzania stanem takie jak Redux Toolkit, Zustand czy MobX. Oferują one bardziej zaawansowane mechanizmy do zarządzania stanem globalnym.

Podsumowanie

Zrozumienie przepływu danych w React jest fundamentem tworzenia przewidywalnych, łatwych w utrzymaniu aplikacji:

  1. Jednokierunkowy przepływ danych - dane płyną z góry na dół, od rodziców do dzieci
  2. Props - podstawowy mechanizm przekazywania danych w dół
  3. Funkcje jako props - mechanizm komunikacji w górę
  4. Lifting state up - technika wynoszenia współdzielonego stanu do wspólnego przodka
  5. Komponenty kontrolowane vs niekontrolowane - różne podejścia do zarządzania danymi formularzy
  6. Context API i biblioteki zarządzania stanem - rozwiązania dla bardziej złożonych przepływów danych

Przestrzegając tych zasad, tworzysz aplikacje, które są łatwiejsze w zrozumieniu, debugowaniu i rozwijaniu - podobnie jak dobrze zaplanowana misja kosmiczna ma jasno określone protokoły komunikacji i przepływu danych.

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

// Komponent dziecka - otrzymuje dane przez props
function MissionInfo({ mission, onStatusChange }) {
  return (
    <div className="mission-info">
      <h3>{mission.name}</h3>
      <p>Status: <span className={`status ${mission.status}`}>{mission.status}</span></p>
      <p>Cel: {mission.destination}</p>
      <p>Załoga: {mission.crew.join(', ')}</p>

      <div className="controls">
        <button
          onClick={() => onStatusChange(mission.id, 'w trakcie')}
          disabled={mission.status === 'w trakcie'}
        >
          Rozpocznij misję
        </button>
        <button
          onClick={() => onStatusChange(mission.id, 'zakończona')}
          disabled={mission.status === 'zakończona'}
        >
          Zakończ misję
        </button>
        <button
          onClick={() => onStatusChange(mission.id, 'anulowana')}
          disabled={mission.status === 'anulowana'}
        >
          Anuluj misję
        </button>
      </div>
    </div>
  );
}

// Komponent rodzica - zarządza stanem i przekazuje dane w dół
function MissionControl() {
  const [missions, setMissions] = useState([
    {
      id: 1,
      name: 'Apollo 21',
      status: 'planowana',
      destination: 'Księżyc',
      crew: ['Anna Kowalska', 'Jan Nowak']
    },
    {
      id: 2,
      name: 'Mars Explorer',
      status: 'planowana',
      destination: 'Mars',
      crew: ['Maria Wiśniewska', 'Piotr Zieliński', 'Katarzyna Dąbrowska']
    },
    {
      id: 3,
      name: 'Titan Survey',
      status: 'w trakcie',
      destination: 'Tytan (księżyc Saturna)',
      crew: ['Tomasz Kowalczyk', 'Agnieszka Nowak']
    }
  ]);

  // Funkcja przekazywana w dół - komunikacja w górę
  const handleStatusChange = (missionId, newStatus) => {
    setMissions(prevMissions =>
      prevMissions.map(mission =>
        mission.id === missionId
          ? { ...mission, status: newStatus }
          : mission
      )
    );
  };

  const getStatusCount = (status) => {
    return missions.filter(mission => mission.status === status).length;
  };

  return (
    <div className="mission-control">
      <h1>Centrum Kontroli Misji</h1>

      <div className="statistics">
        <div className="stat">
          <span className="count">{getStatusCount('planowana')}</span>
          <span className="label">Planowane</span>
        </div>
        <div className="stat">
          <span className="count">{getStatusCount('w trakcie')}</span>
          <span className="label">W trakcie</span>
        </div>
        <div className="stat">
          <span className="count">{getStatusCount('zakończona')}</span>
          <span className="label">Zakończone</span>
        </div>
        <div className="stat">
          <span className="count">{getStatusCount('anulowana')}</span>
          <span className="label">Anulowane</span>
        </div>
      </div>

      <div className="missions-grid">
        {missions.map(mission => (
          <MissionInfo
            key={mission.id}
            mission={mission}
            onStatusChange={handleStatusChange}
          />
        ))}
      </div>
    </div>
  );
}

function App() {
  return (
    <div className="app">
      <MissionControl />
    </div>
  );
}

export default App;

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Zadania praktyczne w grze

  • Edytor kodu

    Stwórz formularz logowania ze stanami [username, setUsername] i [password, setPassword]. Oba pola mają być kontrolowane, np. <input value={username} onChange={e => setUsername(e.target.value)} />, a pole hasła ma type="password". Formularz ma onSubmit={handleLogin}, a handleLogin wywołuje e.preventDefault(). Po wysłaniu wyświetl powitanie Witaj {username} (zapamiętaj w stanie, że formularz został wysłany).

  1. Zadanie z kodemPraktyka: Formularze kontrolowane

Przydatne artykuły