Kurs JavaScript i TypeScript · Moduł 4: Programowanie asynchroniczne
API Fetch
W tej lekcji18
W nowoczesnym Parku Jurajskim, oprócz lokalnych systemów monitorowania i kontroli, potrzebujemy również komunikować się z zewnętrznymi systemami i API. Czy to sprawdzanie prognoz pogodowych dla parku, synchronizacja danych z globalnymi bazami dinozaurów czy integracja z systemami rezerwacji dla odwiedzających - wszystko to wymaga solidnej metody wykonywania żądań HTTP. W tym ćwiczeniu poznamy API Fetch, nowoczesny interfejs do wykonywania żądań sieciowych w JavaScript.
Czym jest Fetch API?
Fetch API to nowoczesny, wbudowany interfejs JavaScript do wykonywania żądań HTTP. Zastępuje starsze podejścia, takie jak XMLHttpRequest, oferując bardziej ergonomiczny i potężny zestaw narzędzi oparty na Promise.
Główne zalety Fetch API:
- Korzysta z Promise, co ułatwia obsługę operacji asynchronicznych
- Ma prostszą i bardziej intuicyjną składnię niż XMLHttpRequest
- Oferuje lepszą kontrolę nad żądaniami HTTP
- Pozwala na łatwe łańcuchowanie operacji asynchronicznych
- Jest standardem przeglądarek i dostępne również w Node.js (od wersji 18)
Podstawowe użycie Fetch
Podstawowa składnia Fetch jest bardzo prosta:
fetch(url)
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Błąd:', error));Przyjrzyjmy się, jak moglibyśmy wykorzystać Fetch w naszym Parku Jurajskim:
// Pobieranie danych o dinozaurze z API
function pobierzDaneDinozaura(id) {
return fetch(`https://api.jurassic-park.com/dinosaurs/${id}`)
.then(response => {
// Sprawdzenie, czy odpowiedź jest poprawna
if (!response.ok) {
throw new Error(`Błąd HTTP: ${response.status}`);
}
return response.json();
})
.then(data => {
console.log(`Pobrano dane dinozaura: ${data.name}`);
return data;
})
.catch(error => {
console.error(`Nie udało się pobrać danych dinozaura #${id}:`, error);
throw error;
});
}
// Użycie funkcji
pobierzDaneDinozaura(42)
.then(dino => {
console.log(`Dinozaur #42: ${dino.name}, Gatunek: ${dino.species}`);
aktualizujPanelInformacyjny(dino);
})
.catch(error => {
wyświetlKomunikatBłędu(`Nie udało się pobrać informacji o dinozaurze: ${error.message}`);
});Wykonywanie różnych typów żądań HTTP
Fetch domyślnie wykonuje żądanie GET, ale możemy łatwo określić inny typ żądania i przesłać dane:
// Aktualizacja danych dinozaura za pomocą żądania PUT
async function aktualizujDaneDinozaura(id, noweDane) {
try {
const response = await fetch(`https://api.jurassic-park.com/dinosaurs/${id}`, {
method: 'PUT',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${apiToken}`
},
body: JSON.stringify(noweDane)
});
if (!response.ok) {
throw new Error(`Błąd podczas aktualizacji: ${response.status}`);
}
const zaktualizowanyDinozaur = await response.json();
console.log(`Zaktualizowano dane dinozaura #${id}`);
return zaktualizowanyDinozaur;
} catch (error) {
console.error(`Błąd aktualizacji dinozaura #${id}:`, error);
throw error;
}
}
// Tworzenie nowego rekordu dinozaura za pomocą żądania POST
async function dodajNowegoDinozaura(dane) {
try {
const response = await fetch('https://api.jurassic-park.com/dinosaurs', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${apiToken}`
},
body: JSON.stringify(dane)
});
if (!response.ok) {
throw new Error(`Błąd podczas dodawania dinozaura: ${response.status}`);
}
const nowyDinozaur = await response.json();
console.log(`Dodano nowego dinozaura #${nowyDinozaur.id}`);
return nowyDinozaur;
} catch (error) {
console.error('Błąd dodawania dinozaura:', error);
throw error;
}
}
// Usunięcie dinozaura za pomocą żądania DELETE
async function usuńDinozaura(id) {
try {
const response = await fetch(`https://api.jurassic-park.com/dinosaurs/${id}`, {
method: 'DELETE',
headers: {
'Authorization': `Bearer ${apiToken}`
}
});
if (!response.ok) {
throw new Error(`Błąd podczas usuwania dinozaura: ${response.status}`);
}
// W przypadku DELETE serwer może nie zwracać danych
if (response.status !== 204) { // No Content
const data = await response.json();
console.log(`Usunięto dinozaura #${id}:`, data);
return data;
}
console.log(`Usunięto dinozaura #${id}`);
return { success: true, id };
} catch (error) {
console.error(`Błąd usuwania dinozaura #${id}:`, error);
throw error;
}
}Obiekt Response
Kiedy wywołujemy funkcję fetch(), zwraca ona Promise, który rozwiązuje się do obiektu Response. Ten obiekt zawiera wszystkie informacje o odpowiedzi HTTP:
fetch('https://api.jurassic-park.com/status')
.then(response => {
console.log('Status:', response.status); // np. 200
console.log('Status OK:', response.ok); // true dla statusu 200-299
console.log('Typ zawartości:', response.headers.get('content-type'));
console.log('Wszystkie nagłówki:', [...response.headers.entries()]);
return response.json(); // Parsowanie odpowiedzi jako JSON
})
.then(data => {
console.log('Dane:', data);
});Obiekt Response oferuje różne metody do przetwarzania danych odpowiedzi:
| Metoda | Opis |
|---|---|
| response.json() | Parsuje zawartość jako JSON i zwraca Promise z wynikiem |
| response.text() | Zwraca Promise z zawartością jako tekst |
| response.blob() | Zwraca Promise z zawartością jako obiekt Blob (dane binarne) |
| response.formData() | Parsuje zawartość jako FormData |
| response.arrayBuffer() | Zwraca Promise z zawartością jako ArrayBuffer |
Ważne jest, aby pamiętać, że możesz wywołać tylko jedną z tych metod na obiekcie Response. Body odpowiedzi może być przetworzone tylko raz, a próba wielokrotnego wywołania np. response.json() spowoduje błąd.
Obsługa błędów w Fetch
Ważną cechą Fetch API jest to, że Promise zwrócony przez fetch() nie zostanie odrzucony dla błędów HTTP, takich jak 404 lub 500. Zostanie odrzucony tylko w przypadku problemów sieciowych, takich jak brak połączenia.
Aby prawidłowo obsługiwać błędy HTTP, należy sprawdzić właściwość response.ok lub kod statusu response.status:
fetch('https://api.jurassic-park.com/dinosaurs/999')
.then(response => {
if (!response.ok) {
// Tworzenie błędu z kodem statusu
throw new Error(`Błąd HTTP: ${response.status}`);
}
return response.json();
})
.then(data => {
console.log('Dane:', data);
})
.catch(error => {
console.error('Błąd:', error.message);
// Tutaj możemy obsłużyć zarówno błędy HTTP, jak i błędy sieci
});Można też rozszerzyć tę logikę, aby lepiej obsługiwać różne kody statusu:
fetch('https://api.jurassic-park.com/dinosaurs/999')
.then(response => {
if (response.status === 404) {
throw new Error('Dinozaur nie znaleziony');
} else if (response.status === 401) {
throw new Error('Brak autoryzacji - zaloguj się ponownie');
} else if (response.status === 403) {
throw new Error('Brak uprawnień do tej operacji');
} else if (!response.ok) {
throw new Error(`Błąd HTTP: ${response.status}`);
}
return response.json();
})
.then(/* ... */)
.catch(/* ... */);Opcje konfiguracyjne Fetch
Fetch przyjmuje opcjonalny drugi argument, który pozwala na dostosowanie żądania:
fetch(url, {
method: 'POST', // Metoda HTTP (GET, POST, PUT, DELETE, itd.)
headers: { // Nagłówki HTTP
'Content-Type': 'application/json',
'Authorization': 'Bearer token123'
},
body: JSON.stringify(data), // Ciało żądania (dla POST, PUT, itd.)
mode: 'cors', // Tryb CORS
credentials: 'include', // Czy dołączać ciasteczka
cache: 'no-cache', // Sposób obsługi cache
redirect: 'follow', // Sposób obsługi przekierowań
referrer: 'no-referrer', // Nagłówek referrer
signal: abortController.signal // Do anulowania żądania
})Przykład z większością opcji
async function wykonajZłożoneŻądanie() {
const abortController = new AbortController();
const signal = abortController.signal;
// Ustawienie timeout dla żądania
const timeout = setTimeout(() => {
abortController.abort();
}, 5000); // 5 sekund
try {
const response = await fetch('https://api.jurassic-park.com/data', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${apiToken}`,
'X-Jurassic-Version': '1.2'
},
body: JSON.stringify({
query: 'velociraptor',
limit: 10,
withDetails: true
}),
mode: 'cors',
credentials: 'include', // Dołącz ciasteczka
cache: 'no-cache', // Nie używaj cache
redirect: 'follow', // Automatycznie podążaj za przekierowaniami
referrer: 'no-referrer',
signal // Do anulowania żądania
});
clearTimeout(timeout);
if (!response.ok) {
throw new Error(`Błąd HTTP: ${response.status}`);
}
return await response.json();
} catch (error) {
clearTimeout(timeout);
if (error.name === 'AbortError') {
console.error('Żądanie przerwane po upływie czasu oczekiwania');
throw new Error('Przekroczono czas oczekiwania na odpowiedź');
}
console.error('Błąd żądania:', error);
throw error;
}
}Anulowanie żądań z AbortController
AbortController to interfejs, który pozwala na anulowanie żądań Fetch. Jest szczególnie przydatny do implementacji timeoutów lub gdy użytkownik chce anulować długotrwałe żądanie:
function pobierzDużeDaneDinozaurów(query) {
// Utworzenie kontrolera anulowania
const controller = new AbortController();
const { signal } = controller;
// Ustawienie timeoutu
const timeoutId = setTimeout(() => {
controller.abort();
}, 10000); // 10 sekund
// Przycisk anulowania dla użytkownika
const cancelButton = document.getElementById('cancel-button');
cancelButton.addEventListener('click', () => {
controller.abort();
clearTimeout(timeoutId);
cancelButton.disabled = true;
cancelButton.textContent = 'Anulowano';
});
// Wykonanie żądania z sygnałem anulowania
return fetch(`https://api.jurassic-park.com/search?q=${query}`, { signal })
.then(response => {
clearTimeout(timeoutId);
if (!response.ok) {
throw new Error(`Błąd HTTP: ${response.status}`);
}
return response.json();
})
.then(data => {
cancelButton.disabled = true;
cancelButton.textContent = 'Zakończono';
return data;
})
.catch(error => {
clearTimeout(timeoutId);
if (error.name === 'AbortError') {
console.log('Żądanie zostało anulowane');
// Obsługujemy anulowanie jako normalny przepływ, nie jako błąd
return { cancelled: true };
}
// Dla innych błędów, przekazujemy dalej
throw error;
});
}Równoległe żądania z Promise.all
Czasami potrzebujemy wykonać wiele żądań jednocześnie. Możemy to zrobić łącząc Fetch z Promise.all:
async function pobierzDaneDlaWybiegu(wybiegId) {
try {
// Definiujemy wszystkie żądania
const dinozauryPromise = fetch(`https://api.jurassic-park.com/paddocks/${wybiegId}/dinosaurs`).then(r => r.json());
const statusPromise = fetch(`https://api.jurassic-park.com/paddocks/${wybiegId}/status`).then(r => r.json());
const historiaPromise = fetch(`https://api.jurassic-park.com/paddocks/${wybiegId}/history`).then(r => r.json());
// Wykonujemy wszystkie żądania równolegle
const [dinozaury, status, historia] = await Promise.all([
dinozauryPromise,
statusPromise,
historiaPromise
]);
// Łączymy dane w jeden obiekt
return {
wybiegId,
dinozaury,
status,
historia,
aktualizacja: new Date()
};
} catch (error) {
console.error(`Błąd pobierania danych dla wybiegu #${wybiegId}:`, error);
throw error;
}
}Obsługa różnych formatów odpowiedzi
Fetch może obsługiwać różne formaty danych, nie tylko JSON:
Tekst zwykły
fetch('https://api.jurassic-park.com/logs')
.then(response => response.text())
.then(text => {
console.log('Logi:', text);
document.getElementById('logs').textContent = text;
});Dane binarne (obrazy, pliki)
// Pobieranie obrazu i wyświetlanie go
fetch('https://api.jurassic-park.com/dinosaurs/42/image')
.then(response => response.blob())
.then(blob => {
const imageUrl = URL.createObjectURL(blob);
document.getElementById('dino-image').src = imageUrl;
});
// Pobieranie i zapisywanie pliku (w środowisku przeglądarki)
fetch('https://api.jurassic-park.com/reports/monthly.pdf')
.then(response => response.blob())
.then(blob => {
const url = URL.createObjectURL(blob);
const a = document.createElement('a');
a.href = url;
a.download = 'raport-miesięczny.pdf';
document.body.appendChild(a);
a.click();
document.body.removeChild(a);
URL.revokeObjectURL(url);
});Wysyłanie formularzy
Fetch może również obsługiwać wysyłanie formularzy:
// Wysyłanie danych formularza jako JSON
document.getElementById('dino-form').addEventListener('submit', async function(e) {
e.preventDefault();
const form = e.target;
const formData = new FormData(form);
// Konwersja FormData do obiektu JavaScript
const formObject = {};
for (const [key, value] of formData.entries()) {
formObject[key] = value;
}
try {
const response = await fetch('https://api.jurassic-park.com/dinosaurs', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify(formObject)
});
if (!response.ok) {
throw new Error(`Błąd HTTP: ${response.status}`);
}
const result = await response.json();
alert(`Dinozaur dodany pomyślnie! ID: ${result.id}`);
form.reset();
} catch (error) {
console.error('Błąd podczas wysyłania formularza:', error);
alert(`Błąd: ${error.message}`);
}
});
// Wysyłanie formularza z plikami
document.getElementById('dino-upload-form').addEventListener('submit', async function(e) {
e.preventDefault();
const form = e.target;
const formData = new FormData(form);
try {
const response = await fetch('https://api.jurassic-park.com/dinosaurs/import', {
method: 'POST',
body: formData // FormData jest automatycznie ustawiane jako 'multipart/form-data'
});
if (!response.ok) {
throw new Error(`Błąd HTTP: ${response.status}`);
}
const result = await response.json();
alert(`Import zakończony! Dodano ${result.count} dinozaurów.`);
} catch (error) {
console.error('Błąd podczas importu:', error);
alert(`Błąd: ${error.message}`);
}
});Obsługa CORS (Cross-Origin Resource Sharing)
CORS to mechanizm bezpieczeństwa, który kontroluje, czy strona może wykonywać żądania do zasobów na innej domenie. Domyślnie, żądania między domenami są zabronione przez politykę "same-origin" przeglądarek.
Podstawowe żądanie CORS:
fetch('https://api.different-domain.com/data', {
mode: 'cors' // Domyślna wartość
})Żądanie z uwierzytelnianiem:
fetch('https://api.different-domain.com/protected-data', {
mode: 'cors',
credentials: 'include' // Wysyła ciasteczka cross-origin
})Opcje dla parametru credentials:
omit: Nie wysyłaj ciasteczek (domyślnie)same-origin: Wysyłaj ciasteczka tylko do tej samej domenyinclude: Wysyłaj ciasteczka również do innych domen
Obsługa cachowania
Fetch pozwala na kontrolowanie, jak przeglądarka używa swojego cache:
// Ignorowanie cache, zawsze wykonaj żądanie do serwera
fetch(url, {
cache: 'no-store'
})
// Najpierw sprawdź cache, jeśli nie ma tam odpowiedzi, wykonaj żądanie
fetch(url, {
cache: 'default'
})
// Najpierw sprawdź cache, ale zweryfikuj z serwerem, czy odpowiedź jest aktualna
fetch(url, {
cache: 'no-cache'
})
// Używaj tylko cache, nie wykonuj żądania sieciowego
fetch(url, {
cache: 'only-if-cached',
mode: 'same-origin' // Wymagane dla 'only-if-cached'
})Praktyczne wzorce z Fetch API
1. Funkcja uniwersalna do żądań API
// Uniwersalna funkcja do wykonywania żądań API
async function apiRequest(endpoint, options = {}) {
const apiBaseUrl = 'https://api.jurassic-park.com';
const url = `${apiBaseUrl}${endpoint}`;
// Domyślne opcje
const defaultOptions = {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${localStorage.getItem('apiToken')}`
},
mode: 'cors'
};
// Łączenie opcji, z priorytetem dla tych przekazanych
const mergedOptions = {
...defaultOptions,
...options,
headers: {
...defaultOptions.headers,
...(options.headers || {})
}
};
// Automatyczne przekształcanie body do JSON, jeśli to obiekt
if (mergedOptions.body && typeof mergedOptions.body === 'object' && !(mergedOptions.body instanceof FormData)) {
mergedOptions.body = JSON.stringify(mergedOptions.body);
}
try {
const response = await fetch(url, mergedOptions);
// Obsługa różnych kodów statusu
if (response.status === 401) {
// Odświeżanie tokenu lub przekierowanie do logowania
await refreshAuthToken();
// Ponowienie żądania z nowym tokenem
return apiRequest(endpoint, options);
}
if (response.status === 204) { // No Content
return { success: true };
}
if (!response.ok) {
// Próba pobrania błędu w formacie JSON
try {
const errorData = await response.json();
throw new Error(errorData.message || `Błąd HTTP: ${response.status}`);
} catch (e) {
// Jeśli nie możemy sparsować błędu jako JSON, użyj prostego komunikatu
throw new Error(`Błąd HTTP: ${response.status}`);
}
}
// Sprawdź Content-Type, aby określić format odpowiedzi
const contentType = response.headers.get('content-type');
if (contentType && contentType.includes('application/json')) {
return await response.json();
} else if (contentType && contentType.includes('text/')) {
return await response.text();
} else {
return await response.blob();
}
} catch (error) {
// Obsługa błędów sieci i innych
console.error(`Błąd żądania API (${endpoint}):`, error);
// Niestandardowy obiekt błędu z dodatkowymi informacjami
const apiError = new Error(error.message);
apiError.isNetworkError = !window.navigator.onLine;
apiError.endpoint = endpoint;
apiError.originalError = error;
throw apiError;
}
}
// Przykład użycia
async function pobierzDinozaury() {
const dinozaury = await apiRequest('/dinosaurs?limit=50');
return dinozaury;
}
async function aktualizujDinozaura(id, dane) {
return apiRequest(`/dinosaurs/${id}`, {
method: 'PUT',
body: dane
});
}
async function importujDaneZPliku(plik) {
const formData = new FormData();
formData.append('file', plik);
return apiRequest('/import', {
method: 'POST',
body: formData,
headers: {
// Usunięcie Content-Type, aby przeglądarka mogła ustawić prawidłowy z boundary
'Content-Type': undefined
}
});
}2. Wzorzec retry - automatyczne ponowne próby po błędzie
/**
* Wykonuje funkcję z automatycznymi ponownymi próbami
* @param {Function} fn - Funkcja do wykonania, która zwraca Promise
* @param {Object} options - Opcje
* @param {number} options.maxRetries - Maksymalna liczba ponownych prób
* @param {number} options.retryDelay - Opóźnienie przed ponowną próbą (ms)
* @param {Function} options.shouldRetry - Funkcja określająca, czy ponawiać próbę
* @param {number} options.backoffFactor - Mnożnik opóźnienia (backoff)
* @returns {Promise} - Promise z wynikiem funkcji lub ostatnim błędem
*/
async function withRetry(fn, options = {}) {
const {
maxRetries = 3,
retryDelay = 1000,
shouldRetry = (error) => true,
backoffFactor = 2
} = options;
let lastError;
for (let attempt = 0; attempt <= maxRetries; attempt++) {
try {
return await fn();
} catch (error) {
lastError = error;
if (attempt === maxRetries || !shouldRetry(error)) {
break;
}
const delay = retryDelay * Math.pow(backoffFactor, attempt);
console.log(`Próba ${attempt + 1} nie powiodła się. Ponowienie za ${delay}ms...`);
await new Promise(resolve => setTimeout(resolve, delay));
}
}
throw lastError;
}
// Przykład użycia z Fetch API
async function pobierzDaneZChwilowegoAPI() {
return withRetry(
() => fetch('https://api.jurassic-park.com/unstable-endpoint')
.then(response => {
if (!response.ok) throw new Error(`HTTP Error: ${response.status}`);
return response.json();
}),
{
maxRetries: 5,
retryDelay: 500,
backoffFactor: 1.5,
shouldRetry: (error) => {
// Ponawiaj próbę tylko dla błędów 5xx (błędy serwera) lub błędów sieci
return error.message.includes('HTTP Error: 5') ||
error instanceof TypeError;
}
}
);
}3. Prosty system cache dla żądań
// Prosty system cache dla żądań GET
const apiCache = {
cache: new Map(),
ttl: 60000, // czas życia cache w ms (1 minuta)
async get(url, options = {}) {
const cacheKey = `${url}|${JSON.stringify(options)}`;
const cachedItem = this.cache.get(cacheKey);
// Jeśli mamy ważny cached item, użyj go
if (cachedItem && Date.now() < cachedItem.expiry) {
console.log(`Używam cache dla: ${url}`);
return cachedItem.data;
}
// W przeciwnym razie wykonaj żądanie
console.log(`Wykonuję żądanie dla: ${url}`);
const response = await fetch(url, options);
if (!response.ok) {
throw new Error(`Błąd HTTP: ${response.status}`);
}
const data = await response.json();
// Zapisz w cache, jeśli to żądanie GET
if (!options.method || options.method === 'GET') {
this.cache.set(cacheKey, {
data,
expiry: Date.now() + this.ttl
});
}
return data;
},
invalidate(urlPattern) {
// Usuń z cache wszystkie klucze pasujące do wzorca
for (const key of this.cache.keys()) {
if (key.includes(urlPattern)) {
this.cache.delete(key);
}
}
},
clear() {
this.cache.clear();
}
};
// Przykład użycia
async function pobierzDaneDinozaura(id) {
return apiCache.get(`https://api.jurassic-park.com/dinosaurs/${id}`);
}
async function zaktualizujDinozaura(id, dane) {
const result = await fetch(`https://api.jurassic-park.com/dinosaurs/${id}`, {
method: 'PUT',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(dane)
}).then(r => r.json());
// Unieważnij cache dla tego dinozaura i list dinozaurów
apiCache.invalidate(`/dinosaurs/${id}`);
apiCache.invalidate('/dinosaurs?');
return result;
}Ograniczenia i kompatybilność Fetch API
Fetch API jest dostępny we wszystkich nowoczesnych przeglądarkach, a od wersji 18 również natywnie w Node.js. Jednak istnieje kilka ograniczeń i problemów z kompatybilnością:
Nie obsługuje postępu żądania - Fetch nie ma wbudowanej obsługi postępu ładowania/wysyłania. Dla takich przypadków czasem lepiej jest użyć XMLHttpRequest.
Nie posiada natywnego timeoutu - Timeout trzeba implementować za pomocą AbortController.
Nie odrzuca Promise dla błędów HTTP - Nawet jeśli serwer zwróci kod błędu, Fetch Promise zostanie rozwiązany. Trzeba sprawdzać response.ok.
W starszych przeglądarkach może być konieczne użycie polyfilla, takiego jak whatwg-fetch lub biblioteki takiej jak axios, która zapewnia jednolite API na różnych środowiskach.
Alternatywy dla Fetch API
Choć Fetch API jest dostępna natywnie, istnieją alternatywy, które mogą zaoferować dodatkowe funkcje:
Axios - Popularna biblioteka, która zapewnia:
- Jednolite API między przeglądarką a Node.js
- Automatyczną transformację danych JSON
- Wbudowaną ochronę przed XSRF
- Obsługę postępu żądania
- Wbudowane timeouty
- Automatyczne ponowne próby
- Anulowanie żądań
jQuery.ajax() - W starszych projektach używających jQuery
XMLHttpRequest - Starsza, bardziej szczegółowa alternatywa, która oferuje więcej kontroli, np. nad postępem żądań
Kiedy używać Fetch API, a kiedy alternatyw?
Fetch jest idealny, gdy:
- Tworzysz nowy projekt
- Chcesz minimalizować zależności
- Potrzebujesz prostych żądań HTTP
- Pracujesz z nowoczesnymi przeglądarkami
Rozważ alternatywy, gdy:
- Potrzebujesz bardziej zaawansowanych funkcji (postęp, wbudowane ponowne próby)
- Musisz wspierać starsze przeglądarki bez polyfillów
- Pracujesz w środowisku, gdzie Fetch nie działa dobrze
- Już używasz biblioteki, która oferuje funkcje HTTP
Dobre praktyki przy pracy z Fetch
Zawsze sprawdzaj response.ok
fetch(url).then(response => { if (!response.ok) throw new Error(`HTTP Error: ${response.status}`); return response.json(); });Ustaw odpowiednie nagłówki
fetch(url, { headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' } });Używaj AbortController dla timeoutów
const controller = new AbortController(); const timeout = setTimeout(() => controller.abort(), 5000); fetch(url, { signal: controller.signal }) .then(response => /* ... */) .catch(error => /* ... */) .finally(() => clearTimeout(timeout));Ostrożnie z przetwarzaniem body
// ŹLE - próba wielokrotnego użycia body fetch(url) .then(response => { const text = response.text(); // To konsumuje body! const json = response.json(); // Błąd - body już zostało zużyte! return /* ... */; }); // DOBRZE - sklonuj response, jeśli potrzebujesz go użyć wielokrotnie fetch(url) .then(response => { const clone = response.clone(); return response.text().then(text => { return clone.json().then(json => { return { text, json }; }); }); });Używaj async/await dla czytelności
// Zamiast łańcuchowania .then() async function fetchData() { try { const response = await fetch(url); if (!response.ok) throw new Error(`HTTP Error: ${response.status}`); const data = await response.json(); return data; } catch (error) { console.error('Błąd:', error); throw error; } }
Podsumowanie
Fetch API jest potężnym, wbudowanym narzędziem do wykonywania żądań HTTP w JavaScript. Jego główne zalety to Promise-based API, prostota użycia i wszechstronność. Chociaż ma pewne ograniczenia w porównaniu do bardziej zaawansowanych bibliotek, jak Axios, dla większości przypadków użycia jest całkowicie wystarczający.
W Parku Jurajskim, gdzie stabilna komunikacja między różnymi systemami jest kluczowa dla bezpieczeństwa odwiedzających i dinozaurów, Fetch API pozwala na niezawodną wymianę danych między systemami monitorującymi, bazami danych i interfejsami użytkownika.
W następnym ćwiczeniu przyjrzymy się, jak łączyć Fetch API z innymi technikami asynchronicznymi, aby tworzyć jeszcze bardziej zaawansowane systemy do zarządzania naszym cyfrowym Parkiem Jurajskim.
Kod do tej lekcji: index.js
// Callback Function Builder - Funkcje zwrotne
console.log("CALLBACK FUNCTIONS - SYSTEM ZDARZEŃ PARKU\n");
// Callback - funkcja przekazana jako argument
function monitorDinosaur(species, callback) {
console.log(`Rozpoczynam monitoring: ${species}`);
// Symulacja monitoringu (synchroniczny dla uproszczenia)
const status = Math.random() > 0.5 ? 'SAFE' : 'ALERT';
const data = {
species: species,
status: status,
timestamp: new Date().toLocaleTimeString()
};
// Wywołanie callback z wynikami
callback(data);
}
// Przykład 1: Prosty callback
console.log("=== PRZYKŁAD 1: PROSTY CALLBACK ===\n");
monitorDinosaur('T-Rex', function(result) {
console.log(`Wynik monitoringu:`);
console.log(` Gatunek: ${result.species}`);
console.log(` Status: ${result.status}`);
console.log(` Czas: ${result.timestamp}`);
});
// Przykład 2: Arrow function jako callback
console.log("\n=== PRZYKŁAD 2: ARROW FUNCTION ===\n");
monitorDinosaur('Velociraptor', (result) => {
const emoji = result.status === 'SAFE' ? 'OK' : '!';
console.log(`${emoji} ${result.species}: ${result.status} (${result.timestamp})`);
});
// Przykład 3: Różne callbacki dla różnych sytuacji
console.log("\n=== PRZYKŁAD 3: WARUNKOWE CALLBACKI ===\n");
function checkDinosaurWithCallbacks(species, onSafe, onAlert) {
const isSafe = Math.random() > 0.5;
if (isSafe) {
onSafe(species);
} else {
onAlert(species);
}
}
checkDinosaurWithCallbacks(
'Triceratops',
(species) => console.log(`${species} jest bezpieczny`),
(species) => console.log(`ALERT! Problem z ${species}!`)
);
// Przykład 4: Callback z array methods
console.log("\n=== PRZYKŁAD 4: ARRAY METHODS Z CALLBACKS ===\n");
const dinosaurs = [
{ name: 'T-Rex', danger: 10 },
{ name: 'Velociraptor', danger: 8 },
{ name: 'Triceratops', danger: 3 },
{ name: 'Brachiosaurus', danger: 2 }
];
console.log("forEach - iteracja:");
dinosaurs.forEach((dino) => {
console.log(` - ${dino.name} (zagrożenie: ${dino.danger})`);
});
console.log("\nfilter - tylko niebezpieczne (>5):");
const dangerous = dinosaurs.filter((dino) => dino.danger > 5);
dangerous.forEach(dino => console.log(` ${dino.name}`));
console.log("\nmap - nazwy:");
const names = dinosaurs.map((dino) => dino.name);
console.log(` ${names.join(', ')}`);
console.log("\nreduce - suma zagrożenia:");
const totalDanger = dinosaurs.reduce((sum, dino) => sum + dino.danger, 0);
console.log(` Łącznie: ${totalDanger}`);
// Przykład 5: Callback hell (problem!)
console.log("\n=== PRZYKŁAD 5: CALLBACK HELL ===\n");
function step1(callback) {
console.log("Krok 1: Sprawdzanie ogrodzenia...");
callback();
}
function step2(callback) {
console.log("Krok 2: Sprawdzanie dinozaurów...");
callback();
}
function step3(callback) {
console.log("Krok 3: Raport końcowy...");
callback();
}
// Zagnieżdżone callbacki (callback hell)
step1(() => {
step2(() => {
step3(() => {
console.log("Wszystkie kroki zakończone");
});
});
});
console.log("\nProblem: Callback hell - trudny do czytania!");
console.log("Rozwiązanie: Promises lub async/await (w następnych lekcjach)");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. Co zwraca funkcja fetch() w JavaScript?
2. Do czego służy AbortController w kontekście Fetch API?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Napisz async function, która pobiera dane z API za pomocą fetch(), parsuje odpowiedź JSON i wyświetla listę dinozaurów.
- Klikanie w kolejności
Ułóż elementy łańcucha Promise:
- Edytor kodu
Napisz kod używający Promise.allSettled do równoległego sprawdzenia kilku czujników. Przeanalizuj wyniki - które się udały (fulfilled), a które nie (rejected).
- Układanie w pionie
Ułóż elementy obsługi błędów w async/await: