Kurs JavaScript i React · Moduł 11: Pobieranie danych i API

POST, PUT, DELETE - Wysyłanie danych do serwera

5 min czytania ·
W tej lekcji6

Do tej pory tylko słuchaliśmy Centrum Dowodzenia: pobieraliśmy dane metodą GET. Ale załoga chce też coś zgłosić: zarejestrować nową misję, poprawić jej cel albo ją odwołać. Sam GET tego nie zrobi. Teraz nauczymy się wysyłać dane do serwera: tworzyć nowe zasoby (POST), aktualizować istniejące (PUT) i usuwać je (DELETE). To jak wysyłanie rozkazów z naszego statku kosmicznego do Centrum Dowodzenia.

Metody HTTP

Metoda HTTP mówi serwerowi, co chcesz zrobić z zasobem pod danym adresem. Ten sam adres /missions/7 może oznaczać "pokaż", "zmień" albo "usuń", zależnie od metody:

// GET    - Pobierz dane (domyślna metoda fetch)
// POST   - Utwórz nowy zasób
// PUT    - Zaktualizuj cały zasób
// PATCH  - Zaktualizuj część zasobu
// DELETE - Usuń zasób

Różnica między PUT a PATCH jest ważna: PUT wysyła cały nowy obiekt i zastępuje nim stary, PATCH wysyła tylko zmienione pola. Jeśli w PUT pominiesz pole, serwer zgodny z tą konwencją może je wyczyścić.

Zapytanie POST - tworzenie nowych zasobów

Domyślnie fetch() wysyła GET. Żeby wysłać dane, przekazujemy drugi argument, obiekt opcji, z trzema polami: method (metoda), headers (nagłówki) i body (treść zapytania):

async function createMission(missionData) {
  const response = await fetch(
    'https://api.space-center.com/missions',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(missionData),
    }
  );

  if (!response.ok) {
    throw new Error('Nie udało się utworzyć misji');
  }

  const newMission = await response.json();
  return newMission;
}

// Użycie:
const mission = await createMission({
  name: 'Alpha Centauri Exploration',
  crew: ['Kapitan Nova', 'Dr. Astro'],
  priority: 'high',
});

Dlaczego JSON.stringify? Pole body przyjmuje tekst, FormData, Blob i kilka innych typów, ale nie serializuje zwykłego obiektu JavaScript. Gdybyś podał obiekt bezpośrednio, poleciałby napis "[object Object]". Sprawdzanie response.ok zostaje takie samo jak przy GET, bo fetch() nie rzuca błędów dla 4xx/5xx także przy POST.

Nagłówki zapytania (Headers)

Nagłówek Content-Type informuje serwer, w jakim formacie wysyłamy dane. Bez niego serwer może nie rozpoznać JSON-a i odrzucić zapytanie:

// JSON - najczęściej używany format
headers: {
  'Content-Type': 'application/json',
}

// Dane formularza
headers: {
  'Content-Type': 'application/x-www-form-urlencoded',
}

// Autoryzacja - token dostępu
headers: {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer eyJhbGciOiJIUzI1NiIs...',
}

Nie myl go z nagłówkiem Accept: on mówi, jaki format chcesz dostać w odpowiedzi. Jedna pułapka: gdy wysyłasz FormData (np. z plikiem), nie ustawiaj Content-Type ręcznie, bo przeglądarka sama doda go razem z granicą części (boundary).

Formularz z POST w React

W prawdziwej aplikacji dane do POST pochodzą z formularza. Potrzebujemy stanów na pola, flagi submitting (żeby zablokować przycisk) oraz stanów na wynik i błąd. Najpierw logika wysyłania:

import React, { useState } from 'react';

function MissionForm() {
  const [name, setName] = useState('');
  const [destination, setDestination] = useState('');
  const [submitting, setSubmitting] = useState(false);
  const [result, setResult] = useState(null);
  const [error, setError] = useState(null);

  const handleSubmit = async (e) => {
    e.preventDefault();
    setSubmitting(true);
    setError(null);

    try {
      const response = await fetch(
        'https://api.space-center.com/missions',
        {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify({ name, destination }),
        }
      );

      if (!response.ok) {
        throw new Error(`Błąd: ${response.status}`);
      }

      const data = await response.json();
      setResult(data);
      setName('');
      setDestination('');
    } catch (err) {
      setError(err.message);
    } finally {
      setSubmitting(false);
    }
  };

e.preventDefault() zatrzymuje domyślne przeładowanie strony przez formularz. Pola czyścimy dopiero po sukcesie, więc przy błędzie użytkownik nie traci wpisanych danych. Druga część tego samego komponentu to widok:

  return (
    <form onSubmit={handleSubmit}>
      <input
        value={name}
        onChange={e => setName(e.target.value)}
        placeholder="Nazwa misji"
        required
      />
      <input
        value={destination}
        onChange={e => setDestination(e.target.value)}
        placeholder="Cel podróży"
        required
      />
      <button type="submit" disabled={submitting}>
        {submitting ? 'Tworzenie misji...' : 'Utwórz misję'}
      </button>

      {error && <p className="error">{error}</p>}
      {result && (
        <p className="success">
          Misja "{result.name}" utworzona! ID: {result.id}
        </p>
      )}
    </form>
  );
}

disabled={submitting} chroni przed podwójnym kliknięciem, które wysłałoby dwie identyczne misje. React 19 dodał też Actions (useActionState, prop action na <form>), które przejmują część tej pracy ze stanem, ale samo zapytanie HTTP wygląda dokładnie tak samo.

PUT - Aktualizacja zasobu

Aktualizacja wygląda prawie jak tworzenie. Zmieniają się dwie rzeczy: metoda na PUT i adres, który teraz wskazuje konkretną misję przez jej id:

async function updateMission(id, updatedData) {
  const response = await fetch(
    `https://api.space-center.com/missions/${id}`,
    {
      method: 'PUT',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(updatedData),
    }
  );

  if (!response.ok) {
    throw new Error('Aktualizacja nie powiodła się');
  }

  return await response.json();
}

Nagłówek i JSON.stringify pozostały bez zmian. Pamiętaj tylko, że updatedData powinno zawierać cały obiekt misji.

DELETE - Usuwanie zasobu

DELETE jest najprostszy, bo zwykle nie wysyła żadnej treści: wystarczy metoda i adres. Serwer często odpowiada kodem 204 No Content, czyli "sukces, ale bez treści", więc nie wołamy wtedy response.json():

async function deleteMission(id) {
  const response = await fetch(
    `https://api.space-center.com/missions/${id}`,
    {
      method: 'DELETE',
    }
  );

  if (!response.ok) {
    throw new Error('Usuwanie nie powiodło się');
  }

  // DELETE często zwraca 204 No Content (brak body)
  return response.status === 204;
}

Wywołanie response.json() na pustej odpowiedzi 204 rzuciłoby błąd parsowania, dlatego zwracamy tylko informację o statusie. Teraz podłączmy tę funkcję do przycisku w komponencie:

// W komponencie React
function MissionItem({ mission, onDelete }) {
  const [deleting, setDeleting] = useState(false);

  const handleDelete = async () => {
    if (!window.confirm('Na pewno usunąć misję?')) return;

    setDeleting(true);
    try {
      await deleteMission(mission.id);
      onDelete(mission.id);
    } catch (err) {
      alert('Błąd: ' + err.message);
    } finally {
      setDeleting(false);
    }
  };

  return (
    <div>
      <h3>{mission.name}</h3>
      <button onClick={handleDelete} disabled={deleting}>
        {deleting ? 'Usuwanie...' : 'Usuń misję'}
      </button>
    </div>
  );
}

Komponent pyta o potwierdzenie, bo usunięcia nie da się cofnąć, a listę aktualizuje rodzic przez onDelete dopiero po sukcesie serwera. Polecam tę kolejność na start. W lekcji o cachowaniu poznasz odważniejszy wariant: optimistic updates, które zmieniają UI jeszcze przed odpowiedzią.

Pamiętaj: GET to nasłuch, a POST, PUT i DELETE to rozkazy wysyłane do Centrum Dowodzenia, każdy z właściwą metodą, nagłówkiem i sprawdzeniem response.ok.

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

// Symulacja serwera API
const mockDatabase = {
  missions: [
    { id: 1, name: "Alpha Mission", destination: "Mars", status: "active" },
    { id: 2, name: "Beta Recon", destination: "Europa", status: "active" },
    { id: 3, name: "Gamma Survey", destination: "Titan", status: "completed" },
  ],
  nextId: 4,
};

function fakeFetchApi(url, options = {}) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const method = (options.method || 'GET').toUpperCase();

      if (method === 'GET') {
        resolve({
          ok: true,
          json: () => Promise.resolve({ missions: [...mockDatabase.missions] }),
        });
      } else if (method === 'POST') {
        const body = JSON.parse(options.body);
        const newMission = { ...body, id: mockDatabase.nextId++, status: 'active' };
        mockDatabase.missions.push(newMission);
        resolve({
          ok: true,
          status: 201,
          json: () => Promise.resolve(newMission),
        });
      } else if (method === 'DELETE') {
        const id = parseInt(url.split('/').pop());
        mockDatabase.missions = mockDatabase.missions.filter(m => m.id !== id);
        resolve({ ok: true, status: 204 });
      }
    }, 800);
  });
}

function MissionControl() {
  const [missions, setMissions] = useState([]);
  const [name, setName] = useState('');
  const [destination, setDestination] = useState('');
  const [submitting, setSubmitting] = useState(false);
  const [loading, setLoading] = useState(false);
  const [message, setMessage] = useState(null);

  const loadMissions = async () => {
    setLoading(true);
    const response = await fakeFetchApi('/api/missions');
    const data = await response.json();
    setMissions(data.missions);
    setLoading(false);
  };

  const createMission = async (e) => {
    e.preventDefault();
    if (!name || !destination) return;
    setSubmitting(true);
    setMessage(null);

    try {
      const response = await fakeFetchApi('/api/missions', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ name, destination }),
      });
      const newMission = await response.json();
      setMissions(prev => [...prev, newMission]);
      setName('');
      setDestination('');
      setMessage({ type: 'success', text: `Misja "${newMission.name}" utworzona!` });
    } catch (err) {
      setMessage({ type: 'error', text: err.message });
    } finally {
      setSubmitting(false);
    }
  };

  const deleteMission = async (id) => {
    try {
      await fakeFetchApi(`/api/missions/${id}`, { method: 'DELETE' });
      setMissions(prev => prev.filter(m => m.id !== id));
      setMessage({ type: 'success', text: 'Misja usunieta' });
    } catch (err) {
      setMessage({ type: 'error', text: err.message });
    }
  };

  React.useEffect(() => { loadMissions(); }, []);

  return (
    <div className="control">
      <h1>Centrum Dowodzenia Misjami</h1>

      <form className="mission-form" onSubmit={createMission}>
        <h3>Nowa Misja (POST)</h3>
        <input value={name} onChange={e => setName(e.target.value)} placeholder="Nazwa misji" />
        <input value={destination} onChange={e => setDestination(e.target.value)} placeholder="Cel podrozy" />
        <button type="submit" disabled={submitting}>
          {submitting ? 'Tworzenie...' : 'Utworz misje (POST)'}
        </button>
      </form>

      {message && (
        <div className={"message " + message.type}>{message.text}</div>
      )}

      <h3>Aktywne misje ({missions.length})</h3>
      {loading ? <p>Ladowanie...</p> : (
        <div className="mission-list">
          {missions.map(m => (
            <div key={m.id} className="mission-card">
              <div>
                <h4>{m.name}</h4>
                <p>Cel: {m.destination} | Status: {m.status}</p>
              </div>
              <button className="delete-btn" onClick={() => deleteMission(m.id)}>
                Usun (DELETE)
              </button>
            </div>
          ))}
        </div>
      )}
    </div>
  );
}

export default MissionControl;

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. Dlaczego w zapytaniu POST używamy JSON.stringify() do przekazania danych w body?

  2. 2. Który nagłówek HTTP informuje serwer, że wysyłamy dane w formacie JSON?

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

Zadania praktyczne w grze

  • Układanie w pionie

    Ułóż kroki cyklu żądanie-odpowiedź HTTP:

  • Edytor kodu

    Formularz z zapytaniem POST

  • Edytor kodu

    Operacje CRUD

  • Układanie w pionie

    Ułóż składnię wywołania fetch z metodą POST i nagłówkiem Content-Type:

  1. Ułóż w kolejnościCykl żądanie-odpowiedź HTTP
  2. PytanieJSON.stringify w zapytaniu POST
  3. PytanieMetoda HTTP POST
  4. Zadanie z kodemPraktyka: Formularz z POST
  5. Zadanie z kodemPraktyka: CRUD z POST i DELETE
  6. Ułóż w kolejnościSkładnia fetch z metodą POST
  7. PytanieOdpowiedź DELETE 204 No Content

Przydatne artykuły