Kurs JavaScript i TypeScript · Moduł 4: Programowanie asynchroniczne

API Fetch

16 min czytania ·
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:

MetodaOpis
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 domeny
  • include: 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ą:

  1. 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.

  2. Nie posiada natywnego timeoutu - Timeout trzeba implementować za pomocą AbortController.

  3. 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:

  1. 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ń
  2. jQuery.ajax() - W starszych projektach używających jQuery

  3. 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

  1. Zawsze sprawdzaj response.ok

    fetch(url).then(response => {
      if (!response.ok) throw new Error(`HTTP Error: ${response.status}`);
      return response.json();
    });
  2. Ustaw odpowiednie nagłówki

    fetch(url, {
      headers: {
        'Content-Type': 'application/json',
        'Accept': 'application/json'
      }
    });
  3. 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));
  4. 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 };
          });
        });
      });
  5. 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. 1. Co zwraca funkcja fetch() w JavaScript?

  2. 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:

  1. PytanieFetch API - metoda GET
  2. PytanieAbortController
  3. PytanieBlok finally
  4. Zadanie z kodemPraktyka: Fetch API - pobieranie danych
  5. Kliknij w kolejnościSortowanie: Promise chain
  6. Zadanie z kodemPraktyka: Promise.allSettled w monitoringu
  7. Ułóż w kolejnościSkładnia try-catch z await

Przydatne artykuły