Kurs JavaScript i TypeScript · Moduł 4: Programowanie asynchroniczne

Przetwarzanie danych JSON i zarządzanie złożonymi strukturami danych

9 min czytania ·
W tej lekcji4

W poprzednich ćwiczeniach nauczyliśmy się pobierać dane z serwerów API za pomocą Fetch i tworzyć zaawansowane klienty HTTP dla naszego Parku Jurajskiego. Teraz przyszedł czas, aby nauczyć się efektywnie przetwarzać, transformować i zarządzać złożonymi strukturami danych JSON, które otrzymujemy z naszych systemów.

JSON (JavaScript Object Notation) to standardowy format wymiany danych, który jest lekki, łatwy do odczytania przez ludzi i prosty do przetwarzania przez maszyny. W Parku Jurajskim używamy JSON do reprezentowania wszystkiego - od danych dinozaurów po statusy systemów bezpieczeństwa i dane odwiedzających.

Podstawy JSON w JavaScript

JSON w JavaScript jest reprezentowany przez dwa główne typy struktur:

  • Obiekty (obiekty JavaScript / hashmapy)
  • Tablice (listy elementów)

Przykładowa struktura JSON reprezentująca dinozaura w naszym parku:

const trex = {
  "id": "dino-001",
  "nazwa": "Rexy",
  "gatunek": "Tyrannosaurus Rex",
  "wiek": 25,
  "statystyki": {
    "waga": 8000,
    "dlugosc": 12.3,
    "wysokosc": 3.6
  },
  "diety": ["mięso", "padlina"],
  "zagrożenie": 5,
  "lokalizacja": {
    "wybieg": "T-Rex Kingdom",
    "koordynaty": {
      "x": 34.5,
      "y": 67.2
    }
  },
  "zachowania": [
    {
      "typ": "polowanie",
      "czestosc": "wysoka",
      "pory": ["rano", "wieczór"]
    },
    {
      "typ": "odpoczynek",
      "czestosc": "średnia",
      "pory": ["południe"]
    }
  ],
  "dataDodania": "2023-06-15T08:30:00Z",
  "aktywny": true
}

Parsowanie i serializacja JSON

JavaScript oferuje dwie podstawowe metody do pracy z JSON:

  1. JSON.parse() - konwertuje string JSON na obiekt JavaScript
  2. JSON.stringify() - konwertuje obiekt JavaScript na string JSON
// Serializacja obiektu do stringa JSON
const trexString = JSON.stringify(trex);
console.log("Zserializowany T-Rex:", trexString);

// Parsowanie stringa JSON z powrotem do obiektu
const parsedTrex = JSON.parse(trexString);
console.log("Sparsowany T-Rex:", parsedTrex);

Dodatkowe parametry JSON.stringify() i JSON.parse()

JSON.stringify() ma dodatkowe parametry, które mogą być przydatne:

// Formatowanie JSON z wcięciami dla czytelności
const prettyTrex = JSON.stringify(trex, null, 2);
console.log("Sformatowany T-Rex:");
console.log(prettyTrex);

// Selektywne serializowanie tylko wybranych pól
const simpleTrex = JSON.stringify(trex, ['id', 'nazwa', 'gatunek', 'wiek']);
console.log("Uproszczony T-Rex:", simpleTrex);

// Własna funkcja zastępcza (replacer)
const customTrex = JSON.stringify(trex, (key, value) => {
  // Ukrywamy dokładne współrzędne z powodów bezpieczeństwa
  if (key === 'koordynaty') return "UKRYTE";
  // Kody poziomu zagrożenia konwertujemy na opis tekstowy
  if (key === 'zagrożenie') {
    const opisy = ["niegroźny", "niski", "umiarkowany", "wysoki", "ekstremalny"];
    return opisy[value - 1] || value;
  }
  return value;
});
console.log("T-Rex z niestandardową serializacją:", customTrex);

Techniki przetwarzania złożonych struktur JSON

Załóżmy, że otrzymaliśmy złożoną strukturę JSON zawierającą dane o wszystkich dinozaurach w parku. Jak możemy efektywnie przetwarzać takie dane?

1. Filtrowanie danych

Filtrowanie to jedna z najczęstszych operacji podczas pracy z kolekcjami danych:

// Załóżmy, że mamy tablicę dinozaurów
const dinozaury = await api.get('/dinozaury');

// Filtrowanie tylko drapieżników
const drapiezniki = dinozaury.filter(dino => dino.diety.includes('mięso'));

// Filtrowanie dinozaurów w określonym wybiegu
const dinoWWybiegu = dinozaury.filter(dino =>
  dino.lokalizacja.wybieg === 'T-Rex Kingdom'
);

// Filtrowanie niebezpiecznych dinozaurów (poziom zagrożenia > 3)
const niebezpieczneDino = dinozaury.filter(dino => dino.zagrożenie > 3);

// Złożone filtrowanie z wieloma warunkami
const niebezpieczneDrapieznikiWZonie = dinozaury.filter(dino =>
  dino.zagrożenie > 3 &&
  dino.diety.includes('mięso') &&
  dino.lokalizacja.wybieg === 'Zone A'
);

2. Mapowanie i transformacja danych

Często potrzebujemy przekształcić dane z jednego formatu na inny, np. do wyświetlenia na interfejsie użytkownika:

// Tworzymy uproszczoną listę dinozaurów dla UI
const prosteDino = dinozaury.map(dino => ({
  id: dino.id,
  nazwa: dino.nazwa,
  gatunek: dino.gatunek,
  zagrożenie: dino.zagrożenie
}));

// Dodajemy nowe pola na podstawie istniejących danych
const dinoZDodatkowymiInformacjami = dinozaury.map(dino => ({
  ...dino, // kopiujemy wszystkie istniejące pola
  wiekLat: dino.wiek, // przemianowanie pola
  zagrozenieOpis: ['niegroźny', 'niski', 'umiarkowany', 'wysoki', 'ekstremalny'][dino.zagrożenie - 1],
  waga_tony: dino.statystyki.waga / 1000,
  wymaga_ochrony: dino.zagrożenie > 3
}));

// Transformacja do specyficznego formatu dla wykresu
const daneDoWykresu = dinozaury.map(dino => ({
  x: dino.statystyki.dlugosc,
  y: dino.statystyki.waga,
  r: dino.zagrożenie * 5, // rozmiar punktu zależny od zagrożenia
  label: dino.nazwa,
  color: dino.diety.includes('mięso') ? 'red' : 'green'
}));

3. Agregacja i redukcja danych

Redukcja pozwala na agregowanie danych w celu uzyskania podsumowań i statystyk:

// Obliczenie średniej wagi wszystkich dinozaurów
const sredniWaga = dinozaury.reduce((suma, dino) => suma + dino.statystyki.waga, 0) / dinozaury.length;

// Znalezienie najdłuższego dinozaura
const najdluzszy = dinozaury.reduce((najdluzszy, dino) =>
  dino.statystyki.dlugosc > najdluzszy.statystyki.dlugosc ? dino : najdluzszy
, dinozaury[0]);

// Grupowanie dinozaurów według gatunków
const dinoPoGatunkach = dinozaury.reduce((grupy, dino) => {
  // Jeśli grupa dla tego gatunku nie istnieje, tworzymy ją
  if (!grupy[dino.gatunek]) {
    grupy[dino.gatunek] = [];
  }
  // Dodajemy dinozaura do odpowiedniej grupy
  grupy[dino.gatunek].push(dino);
  return grupy;
}, {});

// Liczenie dinozaurów według poziomu zagrożenia
const liczbaPoZagrozeniu = dinozaury.reduce((licznik, dino) => {
  licznik[dino.zagrożenie] = (licznik[dino.zagrożenie] || 0) + 1;
  return licznik;
}, {});

4. Łączenie operacji z użyciem łańcuchów metod

Metody tablicowe można łączyć w łańcuchy, co pozwala na pisanie zwięzłego i czytelnego kodu:

// Znajdź 3 najniebezpieczniejsze dinozaury w Zone A
const top3NiebezpieczneWZoneA = dinozaury
  .filter(dino => dino.lokalizacja.wybieg === 'Zone A')
  .sort((a, b) => b.zagrożenie - a.zagrożenie) // sortowanie malejąco
  .slice(0, 3) // weź tylko pierwsze 3
  .map(dino => ({
    nazwa: dino.nazwa,
    gatunek: dino.gatunek,
    zagrożenie: dino.zagrożenie
  }));

// Oblicz średnią wagę dla każdego gatunku
const sredniaWagaPoGatunkach = Object.entries(
  dinozaury.reduce((grupy, dino) => {
    if (!grupy[dino.gatunek]) {
      grupy[dino.gatunek] = { suma: 0, liczba: 0 };
    }
    grupy[dino.gatunek].suma += dino.statystyki.waga;
    grupy[dino.gatunek].liczba += 1;
    return grupy;
  }, {})
).map(([gatunek, { suma, liczba }]) => ({
  gatunek,
  sredniaWaga: suma / liczba
}));

5. Głębokie znajdowanie i aktualizowanie danych

W złożonych strukturach często musimy znaleźć lub zaktualizować głęboko zagnieżdżone dane. Oto kilka podejść:

// Znajdowanie dinozaura na podstawie głęboko zagnieżdżonego warunku
const dinoWPobliżuKoordynatów = dinozaury.find(dino => {
  const { x, y } = dino.lokalizacja.koordynaty;
  // Szukamy dinozaura w promieniu 5 jednostek od punktu (30, 70)
  return Math.sqrt(Math.pow(x - 30, 2) + Math.pow(y - 70, 2)) < 5;
});

// Aktualizacja głęboko zagnieżdżonej właściwości (immutability)
function updateDinoLocation(dino, newX, newY) {
  return {
    ...dino,
    lokalizacja: {
      ...dino.lokalizacja,
      koordynaty: {
        ...dino.lokalizacja.koordynaty,
        x: newX,
        y: newY
      }
    }
  };
}

// Użycie
const updatedDino = updateDinoLocation(trex, 35.0, 68.0);

6. Rekurencyjne przetwarzanie danych

Niektóre struktury danych są hierarchiczne lub mają nieznany poziom zagnieżdżenia. W takich przypadkach przydaje się przetwarzanie rekurencyjne:

// Przykładowa hierarchiczna struktura kategorii dinozaurów
const kategorieDinozaurów = {
  "nazwa": "Dinozaury",
  "podkategorie": [
    {
      "nazwa": "Teropody",
      "podkategorie": [
        {
          "nazwa": "Tyranozauroidy",
          "dinozaury": [
            { "id": "dino-001", "nazwa": "Rexy" },
            { "id": "dino-002", "nazwa": "Tara" }
          ]
        },
        {
          "nazwa": "Deinonychoidy",
          "dinozaury": [
            { "id": "dino-003", "nazwa": "Blue" },
            { "id": "dino-004", "nazwa": "Delta" }
          ]
        }
      ]
    },
    {
      "nazwa": "Zauropody",
      "dinozaury": [
        { "id": "dino-005", "nazwa": "Długi" },
        { "id": "dino-006", "nazwa": "Wysoki" }
      ]
    }
  ]
};

// Funkcja rekurencyjna do znajdowania dinozaura według ID w hierarchii
function znajdzDinozauraPoId(wezel, id) {
  // Sprawdź, czy obecny węzeł ma tablicę dinozaurów
  if (wezel.dinozaury) {
    const znaleziony = wezel.dinozaury.find(dino => dino.id === id);
    if (znaleziony) return znaleziony;
  }

  // Jeśli węzeł ma podkategorie, przeszukaj je rekurencyjnie
  if (wezel.podkategorie) {
    for (const podkategoria of wezel.podkategorie) {
      const znaleziony = znajdzDinozauraPoId(podkategoria, id);
      if (znaleziony) return znaleziony;
    }
  }

  // Nic nie znaleziono
  return null;
}

// Funkcja rekurencyjna do spłaszczania hierarchii i tworzenia listy wszystkich dinozaurów
function pobierzWszystkieDinozaury(wezel, lista = []) {
  if (wezel.dinozaury) {
    lista.push(...wezel.dinozaury);
  }

  if (wezel.podkategorie) {
    for (const podkategoria of wezel.podkategorie) {
      pobierzWszystkieDinozaury(podkategoria, lista);
    }
  }

  return lista;
}

// Użycie
const blue = znajdzDinozauraPoId(kategorieDinozaurów, "dino-003");
console.log("Znaleziony dinozaur:", blue);

const wszystkieDino = pobierzWszystkieDinozaury(kategorieDinozaurów);
console.log("Wszystkie dinozaury:", wszystkieDino);

Praktyczny przykład: System monitorowania dinozaurów

Teraz połączmy wszystkie omówione techniki w jednym praktycznym przykładzie. Załóżmy, że tworzymy panel kontrolny dla kierownika Parku Jurajskiego, który pokazuje status wszystkich dinozaurów w parku.

// Funkcja pobierająca dane z API
async function pobierzDaneDinozaurów() {
  try {
    const odpowiedź = await fetch('https://api.jurassic-park.com/dinozaury');
    if (!odpowiedź.ok) throw new Error(`Błąd HTTP: ${odpowiedź.status}`);
    return await odpowiedź.json();
  } catch (błąd) {
    console.error('Błąd pobierania danych:', błąd);
    // W przypadku błędu zwracamy puste dane
    return { dinozaury: [] };
  }
}

// Funkcja do przetwarzania i przygotowania danych do wyświetlenia
function przetwórzDaneDoWyświetlenia(dane) {
  // Pobieranie głównej tablicy dinozaurów
  const { dinozaury } = dane;

  // Statystyki zbiorcze
  const statystyki = {
    liczba: dinozaury.length,
    liczbaGatunków: new Set(dinozaury.map(d => d.gatunek)).size,
    średniaWaga: dinozaury.reduce((suma, d) => suma + d.statystyki.waga, 0) / dinozaury.length,
    maksymalneZagrożenie: Math.max(...dinozaury.map(d => d.zagrożenie))
  };

  // Grupowanie według wybiegów
  const dinozauryPoWybiegach = dinozaury.reduce((grupy, dino) => {
    const wybieg = dino.lokalizacja.wybieg;
    if (!grupy[wybieg]) grupy[wybieg] = [];
    grupy[wybieg].push(dino);
    return grupy;
  }, {});

  // Liczenie dinozaurów według poziomów zagrożenia
  const liczbaPoZagrożeniu = [1, 2, 3, 4, 5].map(poziom => ({
    poziom,
    liczba: dinozaury.filter(d => d.zagrożenie === poziom).length,
    procent: (dinozaury.filter(d => d.zagrożenie === poziom).length / dinozaury.length) * 100
  }));

  // Identyfikacja potencjalnych zagrożeń
  const zagrożenia = dinozaury
    .filter(d => d.zagrożenie >= 4)
    .map(d => ({
      id: d.id,
      nazwa: d.nazwa,
      gatunek: d.gatunek,
      wybieg: d.lokalizacja.wybieg,
      zagrożenie: d.zagrożenie,
      ostatnieZachowanie: d.zachowania[0]?.typ || 'nieznane',
      koordynaty: d.lokalizacja.koordynaty
    }))
    .sort((a, b) => b.zagrożenie - a.zagrożenie);

  // Przygotowanie danych do wykresu wagowego
  const daneDoWykresuWagi = dinozaury
    .filter(d => d.statystyki.waga > 0) // Odfiltruj brakujące dane
    .map(d => ({
      id: d.id,
      nazwa: d.nazwa,
      gatunek: d.gatunek,
      waga: d.statystyki.waga,
      drapieżnik: d.diety.includes('mięso'),
      rozmiarPunktu: Math.sqrt(d.statystyki.waga) / 5
    }));

  // Ostatnie aktywności (sortowane według daty)
  const ostatnieAktywności = dinozaury
    .filter(d => d.zachowania && d.zachowania.length > 0)
    .flatMap(d => d.zachowania.map(z => ({
      dinoId: d.id,
      dinoNazwa: d.nazwa,
      typ: z.typ,
      czestosc: z.czestosc,
      pory: z.pory
    })))
    .sort((a, b) => a.dinoId.localeCompare(b.dinoId));

  // Zwróć przetworzone dane
  return {
    statystyki,
    dinozauryPoWybiegach,
    liczbaPoZagrożeniu,
    zagrożenia,
    daneDoWykresuWagi,
    ostatnieAktywności,
    surowe: dinozaury // Oryginalne dane, gdyby były potrzebne
  };
}

// Funkcja do renderowania danych na interfejsie użytkownika (przykład)
function wyrenderujPanelKontrolny(przetworzoneDane) {
  // Tutaj kod aktualizujący widoki UI, wykresy, tabele, mapy, itp.
  console.log("Przetworzono dane do panelu kontrolnego:", przetworzoneDane);

  // Przykład renderowania tabeli z zagrożeniami
  const tabelaZagrożeń = document.getElementById('tabela-zagrozen');
  if (tabelaZagrożeń) {
    tabelaZagrożeń.innerHTML = przetworzoneDane.zagrożenia
      .map(z => `
        <tr>
          <td>${z.nazwa}</td>
          <td>${z.gatunek}</td>
          <td>${z.wybieg}</td>
          <td class="zagrozenie-${z.zagrożenie}">${z.zagrożenie}</td>
          <td>${z.ostatnieZachowanie}</td>
          <td>
            <button onclick="pokazNaMapie(${z.koordynaty.x}, ${z.koordynaty.y})">
              Pokaż na mapie
            </button>
          </td>
        </tr>
      `)
      .join('');
  }

  // ... pozostałe elementy UI
}

// Główna funkcja aktualizacji danych
async function aktualizujPanel() {
  // Pobranie danych z API
  const dane = await pobierzDaneDinozaurów();

  // Przetworzenie danych
  const przetworzoneDane = przetwórzDaneDoWyświetlenia(dane);

  // Wyrenderowanie panelu
  wyrenderujPanelKontrolny(przetworzoneDane);
}

// Uruchomienie aktualizacji co 5 minut
aktualizujPanel();
setInterval(aktualizujPanel, 5 * 60 * 1000);

Podsumowanie

W tym ćwiczeniu nauczyliśmy się:

  1. Podstaw serializacji i deserializacji JSON - jak konwertować dane między formatem tekstowym a obiektami JavaScript

  2. Zaawansowanych technik przetwarzania danych:

    • Filtrowanie danych za pomocą .filter()
    • Transformacja danych za pomocą .map()
    • Agregacja danych za pomocą .reduce()
    • Łączenie operacji w łańcuchy
    • Praca z głęboko zagnieżdżonymi strukturami
    • Rekurencyjne przetwarzanie hierarchicznych danych
  3. Praktycznego zastosowania tych technik w kontekście systemu zarządzania parkiem pełnym dinozaurów

Umiejętność efektywnego przetwarzania i analizy danych JSON jest kluczowa dla każdego współczesnego projektu JavaScript - od prostych stron internetowych po złożone aplikacje jak system zarządzania Parkiem Jurajskim. Dzięki technikom, które poznałeś, będziesz mógł przekształcać surowe dane w użyteczne informacje, które pomogą utrzymać park funkcjonujący sprawnie i bezpiecznie... przynajmniej do czasu, gdy raptor znajdzie lukę w systemie!

W następnym ćwiczeniu przyjrzymy się jak tworzyć i korzystać z Web Workers, aby przenieść intensywne obliczenia (jak analizy zachowań dinozaurów) do oddzielnych wątków, nie blokując głównego interfejsu użytkownika.

Kod do tej lekcji: index.js
// Przetwarzanie danych JSON - Park Jurajski
// Praktyka: filtrowanie, mapowanie, redukcja, rekurencja

// === Dane dinozaurow w parku ===
const dinozaury = [
  {
    id: "dino-001",
    nazwa: "Rexy",
    gatunek: "Tyrannosaurus Rex",
    wiek: 25,
    statystyki: { waga: 8000, dlugosc: 12.3, wysokosc: 3.6 },
    diety: ["mieso", "padlina"],
    zagrozenie: 5,
    lokalizacja: { wybieg: "T-Rex Kingdom", koordynaty: { x: 34.5, y: 67.2 } },
    zachowania: [
      { typ: "polowanie", czestosc: "wysoka", pory: ["rano", "wieczor"] }
    ],
    aktywny: true
  },
  {
    id: "dino-002",
    nazwa: "Blue",
    gatunek: "Velociraptor",
    wiek: 8,
    statystyki: { waga: 150, dlugosc: 3.0, wysokosc: 1.8 },
    diety: ["mieso"],
    zagrozenie: 4,
    lokalizacja: { wybieg: "Raptor Paddock", koordynaty: { x: 50.1, y: 30.4 } },
    zachowania: [
      { typ: "polowanie", czestosc: "wysoka", pory: ["rano", "noc"] },
      { typ: "trening", czestosc: "srednia", pory: ["poludnie"] }
    ],
    aktywny: true
  },
  {
    id: "dino-003",
    nazwa: "Brachio",
    gatunek: "Brachiosaurus",
    wiek: 40,
    statystyki: { waga: 56000, dlugosc: 25.0, wysokosc: 13.0 },
    diety: ["rosliny"],
    zagrozenie: 1,
    lokalizacja: { wybieg: "Herbivore Valley", koordynaty: { x: 20.0, y: 45.0 } },
    zachowania: [
      { typ: "pasienie", czestosc: "wysoka", pory: ["rano", "poludnie", "wieczor"] }
    ],
    aktywny: true
  },
  {
    id: "dino-004",
    nazwa: "Spike",
    gatunek: "Triceratops",
    wiek: 15,
    statystyki: { waga: 9000, dlugosc: 9.0, wysokosc: 3.0 },
    diety: ["rosliny"],
    zagrozenie: 2,
    lokalizacja: { wybieg: "Herbivore Valley", koordynaty: { x: 22.5, y: 42.1 } },
    zachowania: [
      { typ: "pasienie", czestosc: "wysoka", pory: ["rano", "poludnie"] },
      { typ: "obrona", czestosc: "niska", pory: ["noc"] }
    ],
    aktywny: true
  },
  {
    id: "dino-005",
    nazwa: "Delta",
    gatunek: "Velociraptor",
    wiek: 6,
    statystyki: { waga: 130, dlugosc: 2.8, wysokosc: 1.6 },
    diety: ["mieso"],
    zagrozenie: 4,
    lokalizacja: { wybieg: "Raptor Paddock", koordynaty: { x: 51.0, y: 31.0 } },
    zachowania: [
      { typ: "polowanie", czestosc: "wysoka", pory: ["noc"] }
    ],
    aktywny: true
  }
];

// === TODO: Cwiczenia do wykonania ===

// 1. Serializacja i deserializacja JSON
const jsonString = JSON.stringify(dinozaury, null, 2);
console.log("=== Serializacja JSON ===");
console.log("Liczba znakow:", jsonString.length);
const parsedDino = JSON.parse(jsonString);
console.log("Sparsowane dinozaury:", parsedDino.length);

// 2. TODO: Filtrowanie - znajdz wszystkie drapiezniki
const drapiezniki = dinozaury.filter(d => d.diety.includes("mieso"));
console.log("\n=== Drapiezniki ===");
drapiezniki.forEach(d => console.log(d.nazwa, "-", d.gatunek));

// 3. TODO: Mapowanie - stworz uproszczona liste
const listaUproszczona = dinozaury.map(d => ({
  nazwa: d.nazwa,
  gatunek: d.gatunek,
  waga_ton: d.statystyki.waga / 1000,
  niebezpieczny: d.zagrozenie >= 4
}));
console.log("\n=== Lista uproszczona ===");
console.log(JSON.stringify(listaUproszczona, null, 2));

// 4. TODO: Redukcja - oblicz srednia wage
const sredniaWaga = dinozaury.reduce(
  (suma, d) => suma + d.statystyki.waga, 0
) / dinozaury.length;
console.log("\n=== Srednia waga ===");
console.log(sredniaWaga.toFixed(1), "kg");

// 5. TODO: Grupowanie po wybiegach
const poWybiegach = dinozaury.reduce((grupy, d) => {
  const wybieg = d.lokalizacja.wybieg;
  if (!grupy[wybieg]) grupy[wybieg] = [];
  grupy[wybieg].push(d.nazwa);
  return grupy;
}, {});
console.log("\n=== Dinozaury w wybiegach ===");
Object.entries(poWybiegach).forEach(([wybieg, nazwy]) =>
  console.log(wybieg + ":", nazwy.join(", "))
);

// 6. TODO: Lancuch metod - top 3 najciezsze
const top3 = dinozaury
  .sort((a, b) => b.statystyki.waga - a.statystyki.waga)
  .slice(0, 3)
  .map(d => d.nazwa + " (" + (d.statystyki.waga / 1000) + "t)");
console.log("\n=== Top 3 najciezsze ===");
top3.forEach((info, i) => console.log((i + 1) + ".", info));

// 7. Dodaj wlasne przetwarzanie danych!
// Np. znajdz dinozaura o najdluzszym ciele, policz drapiezniki vs roslinozerce, itd.

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 robi metoda JSON.parse()?

  2. 2. Co robi trzeci argument w JSON.stringify(obj, null, 2)?

Zadania praktyczne w grze

  • Klikanie w kolejności

    Ułóż elementy pobierania i parsowania JSON z API:

  • Układanie w poziomie

    Ułóż elementy tworzenia Promise:

  • Układanie w poziomie

    Ułóż elementy obsługi Promise z then:

  • Układanie w pionie

    Try-catch

  1. PytanieJSON.parse()
  2. PytanieJSON.stringify() - replacer i space
  3. Kliknij w kolejnościSkładnia parsowania JSON z fetch
  4. Ułóż w kolejnościSkładnia new Promise
  5. Ułóż w kolejnościSkładnia .then()
  6. Ułóż w kolejnościSkładnia try-catch

Przydatne artykuły