Kurs JavaScript i TypeScript · Moduł 2: Funkcje, tablice i obiekty
Iteracja po tablicach (forEach, map, filter, reduce)
W tej lekcji9
W Parku Jurajskim dane o dinozaurach przyrastają szybciej niż same dinozaury - gatunek, wymiary, dieta, poziom agresji, terminy badań weterynaryjnych. Kiedy to wszystko wyląduje w jednej tablicy, pojedynczy wpis przestaje nas obchodzić. Chcemy odwiedzić każdy element, przerobić go na coś innego, wyłowić tylko te okazy, które wymagają reakcji, albo sprowadzić całe stado do jednej liczby na tablicy w centrum kontroli. JavaScript ma na to osobną rodzinę metod iteracyjnych i każda z nich ma inną specjalność. Trafny wybór to różnica między czytelnym raportem bezpieczeństwa a kodem, do którego nikt nie chce wracać.
Metoda forEach
Metoda forEach uruchamia funkcję raz dla każdego elementu tablicy. To najprostszy sposób iteracji - sięgamy po niego wtedy, gdy chcemy z elementami coś zrobić: wypisać je, zapisać do dziennika, wysłać do stacji monitoringu. Nowa tablica nie jest nam wtedy do niczego potrzebna. Funkcja, którą przekazujemy, dostaje bieżący element, a gdy zajdzie taka potrzeba - również jego indeks i całą tablicę.
// Tablica zawierająca obiekty reprezentujące dinozaury w naszym parku
const dinosaurs = [
{ name: "Tyrannosaurus", diet: "carnivore", aggressionLevel: 10, dangerous: true },
{ name: "Triceratops", diet: "herbivore", aggressionLevel: 4, dangerous: false },
{ name: "Velociraptor", diet: "carnivore", aggressionLevel: 9, dangerous: true },
{ name: "Stegosaurus", diet: "herbivore", aggressionLevel: 2, dangerous: false },
{ name: "Brachiosaurus", diet: "herbivore", aggressionLevel: 1, dangerous: false }
];
// Używamy forEach do wyświetlenia nazw wszystkich dinozaurów
console.log("Lista dinozaurów w parku:");
dinosaurs.forEach(function(dino) {
console.log(dino.name);
});
// Możemy również użyć funkcji strzałkowej (arrow function) dla bardziej zwięzłego zapisu
console.log("Lista dinozaurów z poziomem agresji:");
dinosaurs.forEach(dino => {
console.log(`${dino.name}: Poziom agresji ${dino.aggressionLevel}/10`);
});Metoda forEach nie oddaje nam niczego - a dokładniej zwraca undefined - dlatego używamy jej tylko wtedy, gdy zależy nam na samym działaniu na elementach, a nie na wyniku do dalszego przetworzenia. Warto od razu wiedzieć, czego forEach nie potrafi: nie da się jej zatrzymać w połowie. break w środku funkcji zwrotnej jest niedozwolone, a return kończy wyłącznie bieżące wywołanie i przechodzimy prosto do kolejnego dinozaura. Gdy naprawdę potrzebujemy przerwać przebieg wcześniej, robotę biorą na siebie find, some, every albo klasyczna pętla for. Przyjrzyj się jeszcze polu dangerous w naszych kartotekach - to flaga, którą regulamin parku podnosi drapieżnikom pod wzmożonym nadzorem. Wrócimy do niej pod koniec lekcji.
Metoda map
Metoda map tworzy nową tablicę z wynikami wywołania przekazanej funkcji dla każdego elementu tablicy wejściowej. Jest niezwykle przydatna wszędzie tam, gdzie przekształcamy dane z jednej postaci na drugą - z pełnych kartotek na zwykłą listę nazw albo na krótkie podsumowania bezpieczeństwa, które strażnicy faktycznie zdążą przeczytać przed obchodem.
// Używamy map do stworzenia nowej tablicy zawierającej tylko nazwy dinozaurów
const dinoNames = dinosaurs.map(dino => dino.name);
console.log("Nazwy dinozaurów:", dinoNames);
// Wynik: ["Tyrannosaurus", "Triceratops", "Velociraptor", "Stegosaurus", "Brachiosaurus"]
// Możemy też tworzyć bardziej złożone transformacje
const dinoSummaries = dinosaurs.map(dino => {
return {
name: dino.name,
dangerLevel: dino.diet === "carnivore" ? "Wysoki" : "Niski",
warning: dino.aggressionLevel > 7 ? "Zachować szczególną ostrożność!" : "Standardowe procedury bezpieczeństwa"
};
});
console.log("Podsumowanie bezpieczeństwa dinozaurów:", dinoSummaries);W przeciwieństwie do forEach, metoda map zawsze oddaje nową tablicę o tej samej długości co oryginalna, wypełnioną przekształconymi elementami. I na tym właśnie polega kluczowa różnica między nimi: map() zwraca nową tablicę, a forEach() zwraca undefined. To nie jest kwestia wydajności - map() nie jest szybsze, obie metody odwiedzają dokładnie tyle samo elementów, każdy po jednym razie. To także nie jest kwestia przerywania: ani forEach(), ani map() nie da się zatrzymać w trakcie, więc twierdzenie, że tylko jedną z nich można zatrzymać, jest po prostu nieprawdziwe. Nie działają też identycznie - wywołanie forEach w nadziei na odzyskanie tablicy zostawi Cię z undefined w ręku. Po map sięgamy, gdy potrzebujemy wyniku, po forEach - gdy liczy się wyłącznie efekt uboczny.
Metoda filter
Metoda filter tworzy nową tablicę zawierającą tylko te elementy, które spełniają zadany warunek. To idealne narzędzie, gdy z większej kolekcji trzeba wyodrębnić podzbiór: mięsożercy spośród wszystkich dinozaurów, wybiegi do inspekcji spośród wszystkich wybiegów, kartoteki do przekazania weterynarzowi spośród wszystkich kartotek.
// Filtrujemy, aby uzyskać tylko dinozaury mięsożerne
const carnivores = dinosaurs.filter(dino => dino.diet === "carnivore");
console.log("Mięsożerne dinozaury:", carnivores);
// Możemy łączyć warunki, aby tworzyć bardziej złożone filtry
const dangerousDinos = dinosaurs.filter(dino => {
return dino.diet === "carnivore" && dino.aggressionLevel > 7;
});
console.log("Najbardziej niebezpieczne dinozaury:", dangerousDinos);
// Możemy też łączyć filter z map, aby najpierw odfiltrować, a potem przekształcić dane
const safetyWarnings = dinosaurs
.filter(dino => dino.aggressionLevel > 5)
.map(dino => `UWAGA: ${dino.name} ma wysoki poziom agresji!`);
console.log("Ostrzeżenia bezpieczeństwa:", safetyWarnings);Metoda filter zwraca nową tablicę, która bywa krótsza od oryginalnej, bo trafiają do niej wyłącznie elementy, które przeszły przez "filtr" - czyli te, dla których funkcja testująca zwróciła true. Sama tablica dinosaurs wychodzi z tego bez zadraśnięcia: podobnie jak map, filter nigdy nie modyfikuje kolekcji, na której ją wywołujemy, a jedynie o niej raportuje. Zapamiętaj też układ ostatniego przykładu, bo za chwilę okaże się kluczowy: najpierw filtrowanie, dopiero potem transformacja. Ta kolejność nie jest kwestią gustu i zaraz zobaczysz dlaczego.
Metoda reduce
Metoda reduce jest najpotężniejsza z metod iteracyjnych, ale też najbardziej wymagająca. Służy do redukcji tablicy do pojedynczej wartości, na przykład sumy. Wykonuje funkcję na każdym elemencie, przekazując dalej wynik z poprzedniej iteracji: w każdym kroku dostajesz to, co udało się nazbierać do tej pory, oraz bieżący element, a oddajesz nową wartość akumulatora.
// Obliczamy sumę poziomów agresji wszystkich dinozaurów
const totalAggressionLevel = dinosaurs.reduce((total, dino) => {
return total + dino.aggressionLevel;
}, 0); // 0 to wartość początkowa
console.log("Całkowity poziom agresji w parku:", totalAggressionLevel);
// Możemy użyć reduce do tworzenia bardziej złożonych struktur, np. obiektu grupującego dinozaury według diety
const dinosByDiet = dinosaurs.reduce((groups, dino) => {
// Jeśli grupa dla tej diety jeszcze nie istnieje, tworzymy ją
if (!groups[dino.diet]) {
groups[dino.diet] = [];
}
// Dodajemy dinozaura do odpowiedniej grupy
groups[dino.diet].push(dino.name);
return groups;
}, {}); // {} to wartość początkowa (pusty obiekt)
console.log("Dinozaury pogrupowane według diety:", dinosByDiet);
// Wynik: { "carnivore": ["Tyrannosaurus", "Velociraptor"], "herbivore": ["Triceratops", "Stegosaurus", "Brachiosaurus"] }Metoda reduce przyjmuje dwa parametry:
- Funkcję redukcji, która sama przyjmuje co najmniej dwa parametry:
- Akumulator: wartość zwrócona z poprzedniej iteracji (lub wartość początkowa)
- Bieżący element: aktualnie przetwarzany element tablicy
- Wartość początkową (opcjonalną, ale zdecydowanie zalecaną)
Nazwa tej metody bywa myląca, więc uporządkujmy, do czego reduce() nie służy. Nie usuwa elementów z tablicy - obie powyższe operacje przeczytały nasze kartoteki i zostawiły je w spokoju. Nie zmniejsza też rozmiaru tablicy: po wykonaniu obu wywołań dinosaurs nadal liczy pięć wpisów, co do jednego. Nie sortuje niczego malejąco - porządkowaniem elementów zajmuje się sort(), którą poznasz za moment. Słowo "redukcja" oznacza tu dokładnie jedno: sprowadzenie całej tablicy do pojedynczej wartości, czy będzie to liczba, tekst, czy obiekt grupujący pokroju dinosByDiet.
Metoda find
Metoda find zwraca pierwszy element tablicy, który spełnia podany warunek. Po nią sięgamy wtedy, gdy szukamy konkretnej kartoteki, a nie całej listy: strażnik, który prosi "otwórz mi teczkę Stegozaura", nie oczekuje tablicy, tylko jednego dinozaura.
// Szukamy dinozaura o określonej nazwie
const stegosaurus = dinosaurs.find(dino => dino.name === "Stegosaurus");
console.log("Informacje o Stegosaurusie:", stegosaurus);
// Szukamy pierwszego dinozaura mięsożernego o agresji większej niż 8
const dangerousCarnivore = dinosaurs.find(dino => {
return dino.diet === "carnivore" && dino.aggressionLevel > 8;
});
console.log("Pierwszy niebezpieczny mięsożerca:", dangerousCarnivore); // Tyrannosaurus
// findIndex działa tak samo, ale zwraca pozycję zamiast kartoteki
const stegoIndex = dinosaurs.findIndex(dino => dino.name === "Stegosaurus");
console.log("Pozycja Stegosaurusa:", stegoIndex); // 3W przeciwieństwie do filter, który zwraca tablicę wszystkich pasujących elementów, find oddaje tylko pierwsze trafienie i natychmiast przerywa przeszukiwanie - pozostałe dinozaury nie zostaną nawet obejrzane. Jeśli nic nie pasuje, dostajemy undefined. Jej bliźniacza siostra findIndex kieruje się tą samą logiką, ale zamiast elementu podaje jego indeks, a przy braku dopasowania zwraca -1. Bywa to nieocenione, gdy zaraz potem trzeba podmienić kartotekę leżącą na tej pozycji.
Metody some i every
Metody some i every zwracają wartość boolowską i służą do sprawdzania, czy elementy tablicy spełniają określone kryteria. Żadna z nich nie buduje nowej tablicy ani nie oddaje elementów - odpowiadają po prostu true albo false na pytanie o całą kolekcję, co jest dokładnie tym, czego potrzebuje alarm albo kontrola bezpieczeństwa przed otwarciem parku.
some
Metoda some sprawdza, czy przynajmniej jeden element tablicy spełnia podany warunek. Gdy tylko natrafi na pasujący element, kończy przebieg i zwraca true - dalsze szukanie niczego by już nie zmieniło.
// Sprawdzamy, czy w parku są jakieś niebezpieczne dinozaury
const hasHighAggressionDinos = dinosaurs.some(dino => dino.aggressionLevel > 8);
console.log("Czy park ma dinozaury o wysokiej agresji?", hasHighAggressionDinos); // true
// Sprawdzamy, czy w parku są jakieś dinozaury wszystkożerne
const hasOmnivores = dinosaurs.some(dino => dino.diet === "omnivore");
console.log("Czy park ma dinozaury wszystkożerne?", hasOmnivores); // falsePierwsze wywołanie zwraca true, bo Tyranozaur przekracza próg już przy pierwszym sprawdzanym elemencie i dalej nie ma po co iść. Drugie musi przejść całą listę, zanim wyda werdykt: żadna kartoteka nie ma diety "omnivore", więc odpowiedź brzmi false. To właśnie ta rodzina metod potrafi przerwać przebieg w połowie - o forEach i map pamiętaj, że zawsze idą do samego końca tablicy.
every
Metoda every sprawdza, czy wszystkie elementy tablicy spełniają podany warunek. Działa symetrycznie do some: zatrzymuje się na pierwszym elemencie, który obleje test, i od razu zwraca false.
// Sprawdzamy, czy wszystkie dinozaury mają przypisany poziom agresji
const allHaveAggressionLevel = dinosaurs.every(dino => dino.aggressionLevel !== undefined);
console.log("Czy wszystkie dinozaury mają przypisany poziom agresji?", allHaveAggressionLevel); // true
// Sprawdzamy, czy wszystkie dinozaury są roślinożerne
const allHerbivores = dinosaurs.every(dino => dino.diet === "herbivore");
console.log("Czy wszystkie dinozaury są roślinożerne?", allHerbivores); // falsePierwsza kontrola wypada pomyślnie: każda z pięciu kartotek ma uzupełnione pole aggressionLevel, więc every przechodzi całą tablicę i zwraca true. Druga wykłada się już na pierwszym wpisie - Tyranozaur jest mięsożercą - i zwraca false, nie zaglądając do pozostałych. Najłatwiej zapamiętać tę parę jako dwa pytania zadawane na głos: some pyta "czy jest przynajmniej jeden?", a every pyta "czy wszystkie?".
Metoda sort
Metoda sort porządkuje elementy tablicy i zwraca posortowaną tablicę. Domyślnie porównuje je jak ciągi znaków, co przy liczbach potrafi zaskoczyć - tablica [10, 9, 100] wychodzi z takiego sortowania jako [10, 100, 9], bo znak po znaku "1" wypada przed "9". Właśnie dlatego niemal zawsze przekazujemy jej własną funkcję porównującą.
// Sortujemy dinozaury według nazwy (alfabetycznie)
const dinosSortedByName = [...dinosaurs].sort((a, b) => {
return a.name.localeCompare(b.name);
});
console.log("Dinozaury posortowane alfabetycznie:", dinosSortedByName);
// Sortujemy dinozaury według poziomu agresji (od najmniej do najbardziej agresywnych)
const dinosSortedByAggression = [...dinosaurs].sort((a, b) => {
return a.aggressionLevel - b.aggressionLevel;
});
console.log("Dinozaury posortowane według agresji (rosnąco):", dinosSortedByAggression);
// Sortujemy dinozaury według poziomu agresji (od najbardziej do najmniej agresywnych)
const mostDangerousFirst = [...dinosaurs].sort((a, b) => {
return b.aggressionLevel - a.aggressionLevel;
});
console.log("Dinozaury posortowane według agresji (malejąco):", mostDangerousFirst);Kopię tablicy tworzymy operatorem spread (...) nie bez powodu: sort modyfikuje oryginał, a my chcemy zachować pierwotną kolejność rejestru parku. To wielki wyjątek wśród poznanych dotąd metod - map, filter i reduce zostawiają źródło nietknięte, sort nie. O kierunku decyduje funkcja porównująca: wynik ujemny stawia a przed b, dlatego a.aggressionLevel - b.aggressionLevel układa okazy rosnąco, a zamiana operandów miejscami daje porządek malejący. I to sort, wyłącznie sort, odpowiada w JavaScripcie za sortowanie rosnące i malejące.
Łączenie metod
Jedną z najpotężniejszych cech tych metod jest możliwość łączenia ich w "łańcuchy", dzięki czemu złożoną operację na danych zapisujemy jako jedno czytelne wyrażenie. Działa to dlatego, że filter, map i sort oddają tablicę, więc kolejną metodę wywołujemy wprost na wyniku poprzedniej. Najczęstszy wzorzec w parku składa się z dwóch kroków: filtrowania, a zaraz po nim transformacji.
// Źródło, potem filtrowanie, potem transformacja
const dangerousNames = dinosaurs
.filter(d => d.dangerous) // 1. zostawiamy tylko kartoteki z flagą dangerous
.map(d => d.name); // 2. z każdej ocalałej kartoteki bierzemy samą nazwę
console.log("Nazwy niebezpiecznych dinozaurów:", dangerousNames);
// Wynik: ["Tyrannosaurus", "Velociraptor"]Ten łańcuch czytamy od lewej do prawej, a kolejność jego ogniw jest zawsze taka sama: najpierw źródło danych dinosaurs, potem filtrowanie .filter(d => d.dangerous), a na końcu transformacja .map(d => d.name). Ta kolejność nie podlega negocjacjom. Gdyby zamienić dwa ostatnie ogniwa miejscami, map oddałoby tablicę zwykłych napisów, a filter szukałoby potem właściwości dangerous na tekście - wszędzie wypadłoby undefined i w wyniku dostalibyśmy pustą tablicę. Filtrujemy, dopóki mamy jeszcze pełne obiekty, przekształcamy dopiero potem. Gdy ten odruch wejdzie Ci w krew, łańcuch możesz wydłużać dowolnie i wplatać w niego sort albo reduce.
// Znajdźmy nazwy wszystkich dinozaurów roślinożernych, posortowane alfabetycznie
const sortedHerbivoreNames = dinosaurs
.filter(dino => dino.diet === "herbivore") // Najpierw filtrujemy
.map(dino => dino.name) // Potem transformujemy do tablicy nazw
.sort(); // Na końcu sortujemy alfabetycznie
console.log("Roślinożercy (alfabetycznie):", sortedHerbivoreNames);
// Wynik: ["Brachiosaurus", "Stegosaurus", "Triceratops"]
// Obliczmy średni poziom agresji mięsożerców
const averageCarnivoreAggression = dinosaurs
.filter(dino => dino.diet === "carnivore") // Najpierw filtrujemy tylko mięsożerców
.reduce((sum, dino, index, array) => { // Potem redukujemy do średniej
sum += dino.aggressionLevel; // Dodajemy poziom agresji do sumy
// Jeśli to ostatni element, dzielimy przez liczbę elementów
if (index === array.length - 1) {
return sum / array.length;
}
return sum; // Zwracamy sumę częściową
}, 0);
console.log("Średni poziom agresji mięsożerców:", averageCarnivoreAggression); // 9.5Drugi przykład pokazuje, jak elastyczna potrafi być reduce. Funkcja redukcji dostaje nie tylko akumulator i bieżący element, ale też indeks oraz całą przetwarzaną tablicę, dzięki czemu potrafimy rozpoznać ostatnią iterację i w odpowiednim momencie podzielić zebraną sumę. Mięsożerców mamy dwóch, ich poziomy agresji to 10 i 9, więc na wyjściu dostajemy 9.5 - jedną liczbę wyciśniętą z całej tablicy kartotek, czyli dokładnie to, do czego reduce została stworzona.
Podsumowanie
Metody iteracyjne tablic w JavaScript są nieocenionym narzędziem przy pracy z kolekcjami danych. Każda ma swoją specjalizację:
- forEach: gdy chcemy wykonać jakąś operację na każdym elemencie, bez tworzenia nowej tablicy (zwraca
undefined) - map: gdy chcemy przekształcić każdy element tablicy w coś innego (zwraca nową tablicę)
- filter: gdy chcemy wybrać podgrupę elementów spełniających określone kryteria
- reduce: gdy chcemy zredukować tablicę do pojedynczej wartości, na przykład sumy, albo do nowej struktury
- find: gdy szukamy pierwszego elementu spełniającego określone kryterium
- some/every: gdy chcemy sprawdzić, czy pewne/wszystkie elementy spełniają określone kryterium
- sort: gdy chcemy uporządkować elementy tablicy
"Metody iteracyjne to poranna odprawa w parku" - mawia Dr. Rex. "forEach przechodzi codzienną listę kontrolną, filter wyławia tylko te okazy, które wymagają uwagi, map przerabia je na raport, a reduce daje centrum kontroli jedną liczbę, na której da się oprzeć decyzję. Każde narzędzie ma swoje zadanie!"
W naszym Parku Jurajskim te metody są niezbędne do efektywnego zarządzania danymi o dinozaurach, monitorowania bezpieczeństwa i podejmowania decyzji opartych na danych. Zapamiętaj przede wszystkim jedno: metodę dobieramy według tego, co chcemy dostać - efekt uboczny, nową tablicę, podzbiór czy pojedynczą wartość - a reszta kodu napisze się już niemal sama.
Kod do tej lekcji: index.js
// Iteracje po tablicach - Park Jurajski
console.log("Zaawansowane Iteracje");
console.log("forEach, map, filter, reduce\n");
// ===========================================
// DANE TESTOWE
// ===========================================
const dinosaurs = [
{ id: 1, name: "Rexy", species: "T-Rex", age: 8, weight: 8000, sector: "A", health: 95, carnivore: true, fed: true },
{ id: 2, name: "Blue", species: "Velociraptor", age: 5, weight: 80, sector: "B", health: 100, carnivore: true, fed: false },
{ id: 3, name: "Charlie", species: "Velociraptor", age: 5, weight: 80, sector: "B", health: 85, carnivore: true, fed: false },
{ id: 4, name: "Delta", species: "Velociraptor", age: 5, weight: 80, sector: "B", health: 45, carnivore: true, fed: true },
{ id: 5, name: "Trike", species: "Triceratops", age: 7, weight: 9000, sector: "C", health: 70, carnivore: false, fed: true },
{ id: 6, name: "Stego", species: "Stegosaurus", age: 6, weight: 5000, sector: "C", health: 92, carnivore: false, fed: false },
{ id: 7, name: "Brachio", species: "Brachiosaurus", age: 10, weight: 50000, sector: "D", health: 88, carnivore: false, fed: true }
];
// ===========================================
// 1. forEach() - KLASYCZNA ITERACJA
// ===========================================
console.log("=== 1. forEach() - Iteracja bez zwracania ===");
console.log("\nLista wszystkich dinozaurów:");
dinosaurs.forEach((dino, index) => {
const icon = dino.carnivore ? "mięsożerca" : "roślinożerca";
console.log(` ${index + 1}. ${icon} ${dino.name} (${dino.species})`);
});
// forEach z efektami ubocznymi
let totalWeight = 0;
dinosaurs.forEach(dino => {
totalWeight += dino.weight;
});
console.log(`\nŁączna waga: ${totalWeight}kg`);
// ===========================================
// 2. map() - TRANSFORMACJA DANYCH
// ===========================================
console.log("\n=== 2. map() - Transformacja każdego elementu ===");
// Przykład 1: Proste wyciągnięcie wartości
const names = dinosaurs.map(dino => dino.name);
console.log("\nSame imiona:", names.join(", "));
// Przykład 2: Tworzenie nowych obiektów
const summaries = dinosaurs.map(dino => ({
name: dino.name,
type: dino.carnivore ? "Mięsożerca" : "Roślinożerca",
status: dino.health >= 80 ? "Zdrowy" : "Wymaga uwagi"
}));
console.log("\nPodsumowania:");
summaries.forEach(s => {
console.log(` ${s.name}: ${s.type}, Status: ${s.status}`);
});
// Przykład 3: Kalkulacje
const healthPercentages = dinosaurs.map(dino => {
const healthStatus = dino.health >= 90 ? "*" : dino.health >= 70 ? "OK" : "!";
return `${healthStatus} ${dino.name}: ${dino.health}%`;
});
console.log("\nPoziomy zdrowia:");
healthPercentages.forEach(h => console.log(` ${h}`));
// ===========================================
// 3. filter() - FILTROWANIE
// ===========================================
console.log("\n=== 3. filter() - Wybieranie elementów ===");
// Przykład 1: Jeden warunek
const carnivores = dinosaurs.filter(dino => dino.carnivore);
console.log(`\nMięsożercy (${carnivores.length}):`, carnivores.map(d => d.name).join(", "));
// Przykład 2: Wiele warunków
const healthyCarnivores = dinosaurs.filter(dino =>
dino.carnivore && dino.health >= 80
);
console.log(`Zdrowi mięsożercy (${healthyCarnivores.length}):`, healthyCarnivores.map(d => d.name).join(", "));
// Przykład 3: Złożone warunki
const needsAttention = dinosaurs.filter(dino =>
dino.health < 80 || !dino.fed
);
console.log(`\nWymagają uwagi (${needsAttention.length}):`);
needsAttention.forEach(dino => {
const reasons = [];
if (dino.health < 80) reasons.push(`zdrowie: ${dino.health}%`);
if (!dino.fed) reasons.push("głodny");
console.log(` ${dino.name}: ${reasons.join(", ")}`);
});
// Przykład 4: Filtrowanie po sektorze
const sectorB = dinosaurs.filter(dino => dino.sector === "B");
console.log(`\nSektor B (${sectorB.length}):`, sectorB.map(d => d.name).join(", "));
// ===========================================
// 4. reduce() - AGREGACJA
// ===========================================
console.log("\n=== 4. reduce() - Agregacja danych ===");
// Przykład 1: Suma
const totalHealthPoints = dinosaurs.reduce((sum, dino) => sum + dino.health, 0);
console.log(`\nSuma punktów zdrowia: ${totalHealthPoints}`);
// Przykład 2: Średnia
const avgHealth = totalHealthPoints / dinosaurs.length;
console.log(`Średnie zdrowie: ${avgHealth.toFixed(1)}%`);
// Przykład 3: Znajdowanie max/min
const oldest = dinosaurs.reduce((max, dino) =>
dino.age > max.age ? dino : max
);
console.log(`\nNajstarszy: ${oldest.name} (${oldest.age} lat)`);
const youngest = dinosaurs.reduce((min, dino) =>
dino.age < min.age ? dino : min
);
console.log(`Najmłodszy: ${youngest.name} (${youngest.age} lat)`);
// Przykład 4: Grupowanie
const bySector = dinosaurs.reduce((acc, dino) => {
if (!acc[dino.sector]) acc[dino.sector] = [];
acc[dino.sector].push(dino.name);
return acc;
}, {});
console.log("\nGrupowanie po sektorze:");
Object.entries(bySector).sort().forEach(([sector, dinos]) => {
console.log(` Sektor ${sector}: ${dinos.join(", ")}`);
});
// Przykład 5: Liczenie wystąpień
const speciesCount = dinosaurs.reduce((acc, dino) => {
acc[dino.species] = (acc[dino.species] || 0) + 1;
return acc;
}, {});
console.log("\nLiczba według gatunku:");
Object.entries(speciesCount).forEach(([species, count]) => {
console.log(` ${species}: ${count}`);
});
// Przykład 6: Budowanie obiektu statystyk
const stats = dinosaurs.reduce((acc, dino) => {
acc.totalDinos++;
acc.totalWeight += dino.weight;
acc.totalAge += dino.age;
if (dino.carnivore) acc.carnivores++;
if (dino.health >= 90) acc.veryHealthy++;
return acc;
}, { totalDinos: 0, totalWeight: 0, totalAge: 0, carnivores: 0, veryHealthy: 0 });
console.log("\nStatystyki zbiorcze:");
console.log(` Łącznie dinozaurów: ${stats.totalDinos}`);
console.log(` Łączna waga: ${stats.totalWeight}kg`);
console.log(` Średni wiek: ${(stats.totalAge / stats.totalDinos).toFixed(1)} lat`);
console.log(` Mięsożercy: ${stats.carnivores}`);
console.log(` Bardzo zdrowe (≥90%): ${stats.veryHealthy}`);
// ===========================================
// 5. ŁAŃCUCHOWANIE METOD
// ===========================================
console.log("\n=== 5. Łańcuchowanie metod ===");
// Przykład 1: filter + map + sort
const topHealthyCarnivores = dinosaurs
.filter(d => d.carnivore)
.filter(d => d.health >= 80)
.map(d => ({ name: d.name, health: d.health }))
.sort((a, b) => b.health - a.health)
.slice(0, 3);
console.log("\nTOP 3 zdrowych mięsożerców:");
topHealthyCarnivores.forEach((d, i) => {
console.log(` ${i + 1}. ${d.name} - ${d.health}%`);
});
// Przykład 2: filter + map + reduce
const heavyHerbivoreWeight = dinosaurs
.filter(d => !d.carnivore)
.filter(d => d.weight > 1000)
.map(d => d.weight)
.reduce((sum, weight) => sum + weight, 0);
console.log(`\nŁączna waga ciężkich roślinożerców: ${heavyHerbivoreWeight}kg`);
// Przykład 3: Złożone przetwarzanie
const sectorReport = Object.entries(
dinosaurs
.filter(d => d.health >= 70)
.reduce((acc, d) => {
if (!acc[d.sector]) {
acc[d.sector] = { count: 0, avgHealth: 0, totalHealth: 0 };
}
acc[d.sector].count++;
acc[d.sector].totalHealth += d.health;
return acc;
}, {})
)
.map(([sector, data]) => ({
sector,
count: data.count,
avgHealth: (data.totalHealth / data.count).toFixed(1)
}))
.sort((a, b) => b.avgHealth - a.avgHealth);
console.log("\nRaport sektorów (zdrowie ≥70%):");
sectorReport.forEach(s => {
console.log(` Sektor ${s.sector}: ${s.count} dinozaurów, średnie zdrowie: ${s.avgHealth}%`);
});
// ===========================================
// 6. PORÓWNANIE PODEJŚĆ
// ===========================================
console.log("\n=== 6. Porównanie podejść ===");
console.log("\nZadanie: Znajdź imiona mięsożerców w sektorze B");
// Sposób 1: Pętla for (imperatywny)
const result1 = [];
for (let i = 0; i < dinosaurs.length; i++) {
if (dinosaurs[i].carnivore && dinosaurs[i].sector === "B") {
result1.push(dinosaurs[i].name);
}
}
console.log("For loop:", result1);
// Sposób 2: forEach (częściowo funkcyjny)
const result2 = [];
dinosaurs.forEach(dino => {
if (dino.carnivore && dino.sector === "B") {
result2.push(dino.name);
}
});
console.log("forEach:", result2);
// Sposób 3: filter + map (funkcyjny)
const result3 = dinosaurs
.filter(d => d.carnivore && d.sector === "B")
.map(d => d.name);
console.log("filter + map:", result3);
// ===========================================
// 7. PRZYKŁAD KOMPLEKSOWY
// ===========================================
console.log("\n=== 7. System raportowania - przykład kompleksowy ===");
class ParkReportingSystem {
constructor(dinosaurs) {
this.dinosaurs = dinosaurs;
}
// Dashboard główny
getDashboard() {
const total = this.dinosaurs.length;
const healthStats = this.dinosaurs.reduce((acc, d) => {
if (d.health >= 90) acc.excellent++;
else if (d.health >= 70) acc.good++;
else acc.poor++;
acc.total += d.health;
return acc;
}, { excellent: 0, good: 0, poor: 0, total: 0 });
const feedingStats = this.dinosaurs.reduce((acc, d) => {
if (d.fed) acc.fed++;
else acc.hungry++;
return acc;
}, { fed: 0, hungry: 0 });
return {
totalDinosaurs: total,
avgHealth: (healthStats.total / total).toFixed(1),
healthBreakdown: {
excellent: healthStats.excellent,
good: healthStats.good,
poor: healthStats.poor
},
feeding: feedingStats
};
}
// Alert krytyczny
getCriticalAlerts() {
return this.dinosaurs
.filter(d => d.health < 50 || (d.carnivore && !d.fed))
.map(d => ({
name: d.name,
sector: d.sector,
issue: d.health < 50 ? `Krytyczne zdrowie: ${d.health}%` : "Głodny mięsożerca!",
priority: d.health < 50 && d.carnivore && !d.fed ? "EKSTREMALNE" : "WYSOKIE"
}))
.sort((a, b) => {
const priorityOrder = { "EKSTREMALNE": 0, "WYSOKIE": 1 };
return priorityOrder[a.priority] - priorityOrder[b.priority];
});
}
// Ranking zdrowia
getHealthRanking(limit = 5) {
return this.dinosaurs
.map(d => ({
name: d.name,
species: d.species,
health: d.health,
sector: d.sector
}))
.sort((a, b) => b.health - a.health)
.slice(0, limit);
}
// Analiza sektorów
getSectorAnalysis() {
const sectorData = this.dinosaurs.reduce((acc, d) => {
if (!acc[d.sector]) {
acc[d.sector] = {
dinosaurs: [],
totalHealth: 0,
carnivores: 0,
unfed: 0
};
}
acc[d.sector].dinosaurs.push(d.name);
acc[d.sector].totalHealth += d.health;
if (d.carnivore) acc[d.sector].carnivores++;
if (!d.fed) acc[d.sector].unfed++;
return acc;
}, {});
return Object.entries(sectorData)
.map(([sector, data]) => ({
sector,
count: data.dinosaurs.length,
avgHealth: (data.totalHealth / data.dinosaurs.length).toFixed(1),
carnivores: data.carnivores,
unfed: data.unfed,
dinosaurs: data.dinosaurs
}))
.sort((a, b) => a.sector.localeCompare(b.sector));
}
// Wyświetl pełny raport
displayFullReport() {
console.log("\n" + "=".repeat(70));
console.log("PARK JURAJSKI - RAPORT CAŁOŚCIOWY");
console.log("=".repeat(70));
// Dashboard
const dashboard = this.getDashboard();
console.log("\nDASHBOARD");
console.log(` Łącznie dinozaurów: ${dashboard.totalDinosaurs}`);
console.log(` Średnie zdrowie: ${dashboard.avgHealth}%`);
console.log(` Zdrowie - Doskonałe: ${dashboard.healthBreakdown.excellent}, Dobre: ${dashboard.healthBreakdown.good}, Słabe: ${dashboard.healthBreakdown.poor}`);
console.log(` Karmienie - Nakarmione: ${dashboard.feeding.fed}, Głodne: ${dashboard.feeding.hungry}`);
// Alerty
const alerts = this.getCriticalAlerts();
if (alerts.length > 0) {
console.log("\nALERTY KRYTYCZNE");
alerts.forEach((alert, i) => {
console.log(` ${i + 1}. [${alert.priority}] ${alert.name} (Sektor ${alert.sector}): ${alert.issue}`);
});
} else {
console.log("\nBrak alertów krytycznych");
}
// Ranking
const ranking = this.getHealthRanking(5);
console.log("\nTOP 5 - RANKING ZDROWIA");
ranking.forEach((d, i) => {
console.log(` ${i + 1}. ${d.name} (${d.species}) - ${d.health}% - Sektor ${d.sector}`);
});
// Analiza sektorów
const sectorAnalysis = this.getSectorAnalysis();
console.log("\nANALIZA SEKTORÓW");
sectorAnalysis.forEach(sector => {
console.log(` Sektor ${sector.sector}:`);
console.log(` Dinozaury: ${sector.count} - Średnie zdrowie: ${sector.avgHealth}%`);
console.log(` Mięsożercy: ${sector.carnivores}, Głodne: ${sector.unfed}`);
console.log(` Lista: ${sector.dinosaurs.join(", ")}`);
});
}
}
// Uruchom system raportowania
const reportSystem = new ParkReportingSystem(dinosaurs);
reportSystem.displayFullReport();
console.log("\nGratulacje! Opanowałeś zaawansowane iteracje!");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. Jaka jest kluczowa różnica między map() a forEach()?
2. Do czego służy metoda reduce() na tablicy?
Zadania praktyczne w grze
- Układanie w poziomie
Ułóż elementy filtrowania i mapowania tablicy: