Kurs JavaScript i TypeScript · Moduł 4: Programowanie asynchroniczne
Przetwarzanie danych JSON i zarządzanie złożonymi strukturami danych
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:
JSON.parse()- konwertuje string JSON na obiekt JavaScriptJSON.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ę:
Podstaw serializacji i deserializacji JSON - jak konwertować dane między formatem tekstowym a obiektami JavaScript
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
- Filtrowanie danych za pomocą
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. Co robi metoda JSON.parse()?
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