Kurs JavaScript i TypeScript · Moduł 2: Funkcje, tablice i obiekty

Projekt końcowy: System monitorowania dinozaurów

7 min czytania ·
W tej lekcji4

Witaj ponownie w centrum dowodzenia Parku Jurajskiego! W tym module poznałeś funkcje, tablice, zasięg zmiennych, hoisting, słowo kluczowe this, obiekty i prototypy. Teraz nadszedł czas, aby połączyć tę wiedzę w jeden, zintegrowany System Monitorowania Dinozaurów - serce operacyjne całego parku.

Wyobraź sobie centralną konsolę, na której operatorzy parku śledzą w czasie rzeczywistym lokalizację, stan zdrowia i zachowanie każdego dinozaura. Czujniki rozmieszczone po całym parku przesyłają dane, które nasz system musi przetwarzać, filtrować i analizować. Bez sprawnego systemu monitorowania, park szybko wymknąłby się spod kontroli - tak jak w filmie!

W tym projekcie stworzysz kompletny system, który wykorzystuje funkcje strzałkowe do przetwarzania danych, metody tablicowe do filtrowania i transformacji, funkcje wyższego rzędu do elastycznej logiki, a obiekty do modelowania encji parku.

Cel projektu

Zbudujesz system monitorowania, który:

  • Przechowuje dane o dinozaurach w tablicach obiektów
  • Używa funkcji z różnymi typami parametrów (domyślne, rest)
  • Stosuje funkcje strzałkowe do zwięzłego kodu
  • Filtruje, mapuje i redukuje dane za pomocą metod tablicowych
  • Prawidłowo zarządza zasięgiem zmiennych
  • Wykorzystuje obiekty z metodami do modelowania systemu

Wymagania funkcjonalne

1. Baza danych dinozaurów - tablice i obiekty

Pierwszym krokiem jest stworzenie bazy danych parku. Każdy dinozaur jest obiektem z właściwościami, a cała populacja przechowywana jest w tablicy.

// Baza danych dinozaurów parku
const dinosaurs = [
  {
    id: 1,
    name: "Rex",
    species: "Tyrannosaurus Rex",
    weight: 8500,
    diet: "carnivore",
    enclosure: "A-1",
    isHealthy: true,
    heartRate: 72,
    lastFed: "2024-03-15 08:00"
  },
  {
    id: 2,
    name: "Tricia",
    species: "Triceratops",
    weight: 6200,
    diet: "herbivore",
    enclosure: "B-3",
    isHealthy: true,
    heartRate: 55,
    lastFed: "2024-03-15 07:30"
  },
  {
    id: 3,
    name: "Blue",
    species: "Velociraptor",
    weight: 75,
    diet: "carnivore",
    enclosure: "C-2",
    isHealthy: false,
    heartRate: 110,
    lastFed: "2024-03-14 18:00"
  },
  {
    id: 4,
    name: "Dippy",
    species: "Diplodocus",
    weight: 12000,
    diet: "herbivore",
    enclosure: "D-1",
    isHealthy: true,
    heartRate: 40,
    lastFed: "2024-03-15 06:00"
  },
  {
    id: 5,
    name: "Spike",
    species: "Stegosaurus",
    weight: 3500,
    diet: "herbivore",
    enclosure: "B-2",
    isHealthy: true,
    heartRate: 48,
    lastFed: "2024-03-15 07:00"
  }
];

// Dodawanie nowego dinozaura do bazy
const addDinosaur = (name, species, weight, diet, enclosure) => {
  const newId = dinosaurs.length + 1;
  const newDino = {
    id: newId,
    name,
    species,
    weight,
    diet,
    enclosure,
    isHealthy: true,
    heartRate: 60,
    lastFed: new Date().toISOString()
  };
  dinosaurs.push(newDino);
  console.log("Zarejestrowano:", newDino.name, "(" + newDino.species + ")");
  return newDino;
};

addDinosaur("Echo", "Velociraptor", 68, "carnivore", "C-2");
console.log("Łączna liczba dinozaurów:", dinosaurs.length);

2. Filtrowanie i analiza - metody tablicowe

System musi umożliwiać szybkie filtrowanie populacji według różnych kryteriów. Tu wykorzystasz filter, map, reduce i find.

// Filtrowanie drapieżników za pomocą filter
const carnivores = dinosaurs.filter(dino => dino.diet === "carnivore");
console.log("Drapieżniki:", carnivores.map(d => d.name));

// Filtrowanie chorych dinozaurów
const unhealthyDinos = dinosaurs.filter(dino => !dino.isHealthy);
console.log("Wymagają leczenia:", unhealthyDinos.map(d => d.name));

// Mapowanie - tworzenie raportu z imionami i wagami
const weightReport = dinosaurs.map(dino => {
  return {
    name: dino.name,
    weight: dino.weight,
    category: dino.weight > 5000 ? "ciężki" : "lekki"
  };
});
console.log("Raport wagowy:");
weightReport.forEach(entry => {
  console.log("  " + entry.name + ": " + entry.weight + " kg (" + entry.category + ")");
});

// Redukcja - obliczanie łącznej wagi wszystkich dinozaurów
const totalWeight = dinosaurs.reduce((sum, dino) => sum + dino.weight, 0);
console.log("Łączna waga populacji:", totalWeight, "kg");

// Średnia waga
const avgWeight = totalWeight / dinosaurs.length;
console.log("Średnia waga:", Math.round(avgWeight), "kg");

// Znajdowanie najcięższego dinozaura
const heaviest = dinosaurs.reduce((max, dino) =>
  dino.weight > max.weight ? dino : max
);
console.log("Najcięższy:", heaviest.name, "-", heaviest.weight, "kg");

// find - szukanie konkretnego dinozaura
const blue = dinosaurs.find(dino => dino.name === "Blue");
console.log("Znaleziono:", blue ? blue.name + " w " + blue.enclosure : "nie znaleziono");

// some i every - sprawdzanie warunków
const allHealthy = dinosaurs.every(dino => dino.isHealthy);
const anyUnhealthy = dinosaurs.some(dino => !dino.isHealthy);
console.log("Wszystkie zdrowe:", allHealthy);
console.log("Są chore dinozaury:", anyUnhealthy);

3. Funkcje monitorujące - parametry, scope i this

System potrzebuje zestawu funkcji monitorujących z różnymi typami parametrów. Zwróć uwagę na zasięg zmiennych i różnicę między funkcjami zwykłymi a strzałkowymi w kontekście this.

// Funkcja z parametrami domyślnymi
function generateAlert(dinoName, alertType = "INFO", priority = "normal") {
  const timestamp = new Date().toLocaleTimeString();
  console.log("[" + timestamp + "] [" + alertType + "] [" + priority + "] " + dinoName);
}

generateAlert("Rex", "WARNING", "high");
generateAlert("Tricia"); // użyje domyślnych wartości
generateAlert("Blue", "DANGER"); // priority będzie "normal"

// Funkcja z parametrem rest - rejestracja wielu zdarzeń
const logEvents = (enclosure, ...events) => {
  console.log("Wybieg " + enclosure + " - zarejestrowano " + events.length + " zdarzeń:");
  events.forEach((event, index) => {
    console.log("  " + (index + 1) + ". " + event);
  });
};

logEvents("A-1", "Karmienie o 8:00", "Badanie weterynaryjne", "Aktywność ruchowa");
logEvents("C-2", "Próba ucieczki!");

// Obiekt monitora z metodami - this w kontekście
const enclosureMonitor = {
  sector: "A",
  alertCount: 0,

  // Metoda tradycyjna - this wskazuje na obiekt
  checkFence: function() {
    this.alertCount++;
    console.log("Sprawdzanie ogrodzenia sektora " + this.sector +
                " (alert #" + this.alertCount + ")");
  },

  // Metoda skrócona ES6
  getStatus() {
    return "Sektor " + this.sector + " - " + this.alertCount + " alertów";
  }
};

enclosureMonitor.checkFence();
enclosureMonitor.checkFence();
console.log(enclosureMonitor.getStatus());

// Zasięg zmiennych - blokowy vs funkcyjny
function monitorHeartRates() {
  const threshold = 100; // dostępna w całej funkcji

  for (let i = 0; i < dinosaurs.length; i++) {
    const dino = dinosaurs[i]; // dostępna tylko w tym bloku
    if (dino.heartRate > threshold) {
      let pulseStatus = "PODWYŻSZONE"; // dostępna tylko w tym if
      console.log(dino.name + ": tętno " + dino.heartRate + " - " + pulseStatus);
    }
  }

  // console.log(pulseStatus); // BŁĄD! pulseStatus nie istnieje poza blokiem if
  // console.log(dino);   // BŁĄD! dino nie istnieje poza pętlą for
  console.log("Próg alertu:", threshold); // OK - threshold jest w zakresie funkcji
}

monitorHeartRates();

4. Zaawansowane przetwarzanie - łączenie metod

W prawdziwym systemie monitorowania często musimy połączyć wiele operacji w łańcuch. Metody tablicowe świetnie się do tego nadają.

// Łańcuch metod - raport bezpieczeństwa
const securityReport = dinosaurs
  .filter(dino => dino.diet === "carnivore") // tylko drapieżniki
  .map(dino => ({                            // transformacja danych
    name: dino.name,
    enclosure: dino.enclosure,
    danger: dino.weight > 1000 ? "WYSOKIE" : "ŚREDNIE"
  }))
  .sort((a, b) => a.name.localeCompare(b.name)); // sortowanie

console.log("=== RAPORT BEZPIECZEŃSTWA ===");
securityReport.forEach(entry => {
  console.log(entry.name + " [" + entry.enclosure + "] - zagrożenie: " + entry.danger);
});

// Grupowanie dinozaurów według diety za pomocą reduce
const groupedByDiet = dinosaurs.reduce((groups, dino) => {
  const key = dino.diet;
  if (!groups[key]) {
    groups[key] = [];
  }
  groups[key].push(dino.name);
  return groups;
}, {});

console.log("=== PODZIAŁ WEDŁUG DIETY ===");
console.log("Roślinożercy:", groupedByDiet.herbivore);
console.log("Mięsożercy:", groupedByDiet.carnivore);

// Funkcja wyższego rzędu - tworzenie filtrów
function createFilter(property, value) {
  return (dino) => dino[property] === value;
}

const isCarnivore = createFilter("diet", "carnivore");
const isInSectorB = createFilter("enclosure", "B-3");

const carnivoreDinos = dinosaurs.filter(isCarnivore);
const sectorBDinos = dinosaurs.filter(isInSectorB);

console.log("Mięsożercy:", carnivoreDinos.map(d => d.name));
console.log("Sektor B-3:", sectorBDinos.map(d => d.name));

// Statystyki populacji
const stats = {
  total: dinosaurs.length,
  healthy: dinosaurs.filter(d => d.isHealthy).length,
  unhealthy: dinosaurs.filter(d => !d.isHealthy).length,
  avgHeartRate: Math.round(
    dinosaurs.reduce((sum, d) => sum + d.heartRate, 0) / dinosaurs.length
  ),
  heaviest: dinosaurs.reduce((max, d) => d.weight > max.weight ? d : max).name,
  lightest: dinosaurs.reduce((min, d) => d.weight < min.weight ? d : min).name
};

console.log("=== STATYSTYKI POPULACJI ===");
console.log("Łącznie:", stats.total);
console.log("Zdrowe:", stats.healthy);
console.log("Chore:", stats.unhealthy);
console.log("Średnie tętno:", stats.avgHeartRate, "bpm");
console.log("Najcięższy:", stats.heaviest);
console.log("Najlżejszy:", stats.lightest);

Wskazówki implementacyjne

Budując swój system monitorowania, zwróć uwagę na:

  1. Funkcje strzałkowe vs zwykłe - używaj strzałkowych dla callbacków (filter, map, reduce), a zwykłych dla metod obiektów, które potrzebują this
  2. Parametry domyślne - przydatne gdy nie zawsze mamy wszystkie dane (np. priorytet alertu)
  3. Parametr rest (...args) - idealny gdy liczba argumentów jest zmienna (np. lista zdarzeń)
  4. Łańcuchowanie metod - filter().map().sort() jest czytelniejsze niż zagnieżdżone pętle
  5. Zasięg zmiennych - let i const mają zasięg blokowy, var funkcyjny - wybieraj świadomie
  6. Metody tablicowe a oryginał - filter i map tworzą nowe tablice, a reduce zwraca nową wartość, natomiast push, splice i sort modyfikują oryginał
  7. Obiekty jako struktury danych - grupuj powiązane dane w obiekty zamiast trzymać je w osobnych zmiennych

Powodzenia!

Czas wcielić się w rolę głównego operatora Parku Jurajskiego! Stwórz swój własny System Monitorowania w edytorze poniżej. Połącz tablice, funkcje, metody tablicowe i obiekty w jeden, działający system. Pamiętaj - każdy dinozaur w parku zależy od Twojego kodu. Jak mówił John Hammond: "Nie szczędziliśmy wydatków" - i Ty nie szczędź kodu!

Kod do tej lekcji: index.js
// Projekt koncowy: System monitorowania dinozaurow
// Polacz: funkcje, tablice, arrow functions, scope, this, obiekty

// === 1. BAZA DANYCH PARKU ===
const dinosaurs = [
  { id: 1, name: "Rex", species: "Tyrannosaurus", weight: 8500, diet: "carnivore", enclosure: "A-1", isHealthy: true, heartRate: 72 },
  { id: 2, name: "Tricia", species: "Triceratops", weight: 6200, diet: "herbivore", enclosure: "B-3", isHealthy: true, heartRate: 55 },
  { id: 3, name: "Blue", species: "Velociraptor", weight: 75, diet: "carnivore", enclosure: "C-2", isHealthy: false, heartRate: 110 },
];

// === 2. SYSTEM MONITOROWANIA ===
// TODO: Stworz obiekt monitoringSystem z metodami uzywajacymi this
const monitoringSystem = {
  parkName: "Jurassic Park",
  alerts: [],

  // TODO: Metoda filtrujaca dinozaury po diecie (uzyj arrow function)
  filterByDiet: (dinos, diet) => {
    // TODO: Uzyj filter()
  },

  // TODO: Metoda generujaca raport zdrowia (uzyj map)
  getHealthReport(dinos) {
    // TODO: Uzyj map() do stworzenia raportu dla kazdego dinozaura
    // Zwroc tablice obiektow: { name, status, heartRate }
  },

  // TODO: Metoda obliczajaca srednia wage (uzyj reduce)
  calculateAverageWeight(dinos) {
    // TODO: Uzyj reduce() do obliczenia sredniej
  },

  // TODO: Metoda dodajaca alert
  addAlert(message, severity) {
    // TODO: Dodaj alert z timestamp do this.alerts
  },
};

// === 3. FUNKCJE WYZSZEGO RZEDU ===
// TODO: Stworz funkcje createFilter ktora zwraca funkcje filtrujaca
function createFilter(property, value) {
  // TODO: Zwroc arrow function ktora filtruje po podanej wlasciwosci
}

// === 4. RAPORT KONCOWY ===
// TODO: Wygeneruj i wyswietl pelny raport monitoringu
// - Lista dinozaurow po diecie
// - Raport zdrowia
// - Srednia waga
// - Aktywne alerty

console.log("System monitorowania uruchomiony!");

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

  1. Projekt do wysłaniaLink - Systemy sterowania Parku
  2. WideoVideo: Podsumowanie modułu

Przydatne artykuły