Kurs JavaScript i React · Moduł 11: Pobieranie danych i API
POST, PUT, DELETE - Wysyłanie danych do serwera
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óbRóż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. Dlaczego w zapytaniu POST używamy JSON.stringify() do przekazania danych w body?
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: