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

Podstawowe metody tablic w JavaScript

18 min czytania ·
W tej lekcji3

Witaj ponownie w Parku Jurajskim! W poprzedniej lekcji poznaliśmy podstawy tablic w JavaScript. Teraz zagłębimy się w podstawowe metody tablic, które są niezbędne do codziennej pracy z danymi. Te metody pozwalają na dodawanie, usuwanie i manipulowanie elementami w tablicach, co jest kluczowe przy zarządzaniu inwentarzem dinozaurów, planowaniu karmienia czy organizacji personelu parku.

Modyfikacja tablic - metody zmieniające tablicę

Najpierw przyjrzyjmy się metodom, które modyfikują oryginalną tablicę. Są to tak zwane metody mutujące (ang. mutating methods).

1. push() - dodawanie elementów na końcu tablicy

Metoda push() dodaje jeden lub więcej elementów na końcu tablicy i zwraca nową długość tablicy:

// Zarządzanie gatunkami dinozaurów w naszej zagrodzie
const dinoEnclosure = ["T-Rex", "Velociraptor"];

// Dodajemy nowy gatunek dinozaura
dinoEnclosure.push("Dilophosaurus");
console.log(dinoEnclosure); // ["T-Rex", "Velociraptor", "Dilophosaurus"]

// Dodajemy kilka gatunków naraz
const newLength = dinoEnclosure.push("Gallimimus", "Compsognathus");
console.log(dinoEnclosure);
// ["T-Rex", "Velociraptor", "Dilophosaurus", "Gallimimus", "Compsognathus"]
console.log(`Aktualna liczba gatunków w zagrodzie: ${newLength}`); // 5

Kiedy warto używać push():

  • Gdy potrzebujesz dodać element(y) na końcu tablicy
  • Gdy chcesz śledzić nową długość tablicy po dodaniu elementów
  • Gdy kolejność elementów jest istotna, a nowy element powinien znaleźć się na końcu

2. pop() - usuwanie ostatniego elementu

Metoda pop() usuwa ostatni element z tablicy i zwraca ten element:

// Lista dinozaurów w naszej zagrodzie
const dinoEnclosure = ["T-Rex", "Velociraptor", "Dilophosaurus", "Compsognathus"];

// Przenoszenie ostatniego dinozaura do nowej zagrody
const removedDino = dinoEnclosure.pop();
console.log(`Przeniesiono dinozaura: ${removedDino}`); // "Compsognathus"
console.log("Pozostałe dinozaury:", dinoEnclosure); // ["T-Rex", "Velociraptor", "Dilophosaurus"]

// Możemy kontynuować usuwanie
const anotherRemovedDino = dinoEnclosure.pop();
console.log(`Przeniesiono kolejnego dinozaura: ${anotherRemovedDino}`); // "Dilophosaurus"
console.log("Aktualna zawartość zagrody:", dinoEnclosure); // ["T-Rex", "Velociraptor"]

Kiedy warto używać pop():

  • Gdy potrzebujesz usunąć ostatni element z tablicy
  • Gdy potrzebujesz pobrać wartość usuwanego elementu
  • Implementując struktury danych typu stos (LIFO - Last In, First Out)

3. unshift() - dodawanie elementów na początku

Metoda unshift() dodaje jeden lub więcej elementów na początku tablicy i zwraca nową długość tablicy:

// Kolejka dinozaurów oczekujących na badania
const dinoQueue = ["Velociraptor", "Triceratops"];

// Priorytetowe dodanie T-Rexa na początek kolejki
dinoQueue.unshift("T-Rex");
console.log("Aktualna kolejka:", dinoQueue); // ["T-Rex", "Velociraptor", "Triceratops"]

// Dodanie kilku dinozaurów naraz na początek
const newQueueSize = dinoQueue.unshift("Brachiosaurus", "Stegosaurus");
console.log("Aktualna kolejka:", dinoQueue);
// ["Brachiosaurus", "Stegosaurus", "T-Rex", "Velociraptor", "Triceratops"]
console.log(`Liczba dinozaurów w kolejce: ${newQueueSize}`); // 5

Kiedy warto używać unshift():

  • Gdy chcesz dodać element na początek tablicy
  • Implementując kolejki priorytetowe, gdzie elementy z wyższym priorytetem idą na początek
  • Gdy potrzebujesz śledzić nową długość tablicy

4. shift() - usuwanie pierwszego elementu

Metoda shift() usuwa pierwszy element z tablicy i zwraca ten element:

// Kolejka dinozaurów oczekujących na badania
const dinoQueue = ["T-Rex", "Velociraptor", "Triceratops", "Stegosaurus"];

// Pobieramy pierwszego dinozaura do badań
const nextDino = dinoQueue.shift();
console.log(`Badamy dinozaura: ${nextDino}`); // "T-Rex"
console.log("Pozostała kolejka:", dinoQueue); // ["Velociraptor", "Triceratops", "Stegosaurus"]

// Obsługa kolejnego dinozaura
const anotherDino = dinoQueue.shift();
console.log(`Następny dinozaur do badań: ${anotherDino}`); // "Velociraptor"
console.log("Aktualny stan kolejki:", dinoQueue); // ["Triceratops", "Stegosaurus"]

Kiedy warto używać shift():

  • Gdy potrzebujesz usunąć i pobrać pierwszy element tablicy
  • Implementując kolejki (FIFO - First In, First Out)
  • Przetwarzając elementy w kolejności ich dodania

5. splice() - modyfikacja elementów w dowolnym miejscu

Metoda splice() zmienia zawartość tablicy, usuwając, zamieniając lub dodając elementy. Jest niezwykle wszechstronna, ponieważ pozwala na modyfikację tablicy w dowolnym miejscu.

Podstawowa składnia: array.splice(startIndex, deleteCount, item1, item2, ...):

  • startIndex: indeks, od którego zacząć zmianę
  • deleteCount: liczba elementów do usunięcia
  • item1, item2, ...: (opcjonalnie) elementy do dodania

5.1. Usuwanie elementów za pomocą splice()

// Lista gatunków dinozaurów w parku
const dinosaurs = ["T-Rex", "Velociraptor", "Triceratops", "Stegosaurus", "Brachiosaurus"];

// Usuwamy 2 elementy zaczynając od indeksu 1 (drugiego elementu)
const removedDinos = dinosaurs.splice(1, 2);
console.log("Usunięte dinozaury:", removedDinos); // ["Velociraptor", "Triceratops"]
console.log("Pozostałe dinozaury:", dinosaurs); // ["T-Rex", "Stegosaurus", "Brachiosaurus"]

5.2. Zastępowanie elementów za pomocą splice()

// Lista gatunków dinozaurów
const dinosaurs = ["T-Rex", "Dilophosaurus", "Triceratops", "Stegosaurus"];

// Zastępujemy Dilophosaurus przez Velociraptor
const replaced = dinosaurs.splice(1, 1, "Velociraptor");
console.log("Zastąpiony dinozaur:", replaced); // ["Dilophosaurus"]
console.log("Aktualna lista:", dinosaurs); // ["T-Rex", "Velociraptor", "Triceratops", "Stegosaurus"]

// Zastępujemy wiele elementów naraz
dinosaurs.splice(2, 2, "Brachiosaurus", "Ankylosaurus", "Parasaurolophus");
console.log("Nowy skład:", dinosaurs);
// ["T-Rex", "Velociraptor", "Brachiosaurus", "Ankylosaurus", "Parasaurolophus"]

5.3. Dodawanie elementów bez usuwania

// Lista gatunków dinozaurów
const dinosaurs = ["T-Rex", "Velociraptor"];

// Dodajemy nowe gatunki na indeksie 1 (między T-Rex a Velociraptor)
dinosaurs.splice(1, 0, "Dilophosaurus", "Compsognathus");
console.log(dinosaurs); // ["T-Rex", "Dilophosaurus", "Compsognathus", "Velociraptor"]

Kiedy warto używać splice():

  • Gdy potrzebujesz modyfikować tablicę w określonym miejscu, a nie tylko na końcu czy początku
  • Gdy potrzebujesz usunąć i/lub dodać elementy jednocześnie
  • Gdy chcesz zastąpić sekcję tablicy nowymi wartościami

6. sort() - sortowanie tablicy

Metoda sort() sortuje elementy tablicy na miejscu i zwraca posortowaną tablicę:

// Lista dinozaurów do karmienia
const feedingList = ["Velociraptor", "T-Rex", "Dilophosaurus", "Gallimimus", "Compsognathus"];

// Sortowanie alfabetyczne
feedingList.sort();
console.log("Lista karmienia (alfabetycznie):", feedingList);
// ["Compsognathus", "Dilophosaurus", "Gallimimus", "T-Rex", "Velociraptor"]

// Tablica z wymiarami dinozaurów (w cm)
const dinoSizes = [1200, 300, 800, 2000, 40];

// Domyślne sortowanie traktuje liczby jako stringi - to nie zadziała poprawnie!
dinoSizes.sort();
console.log("Niepoprawnie posortowane wymiary:", dinoSizes);
// Prawdopodobnie: [1200, 2000, 300, 40, 800] - niepoprawnie!

// Właściwe sortowanie liczb z funkcją porównującą
dinoSizes.sort((a, b) => a - b);
console.log("Poprawnie posortowane wymiary (rosnąco):", dinoSizes);
// [40, 300, 800, 1200, 2000]

// Sortowanie malejąco
dinoSizes.sort((a, b) => b - a);
console.log("Wymiary posortowane malejąco:", dinoSizes);
// [2000, 1200, 800, 300, 40]

Sortowanie obiektów

// Dane dinozaurów do karmienia
const dinosaurs = [
  { name: "T-Rex", weight: 7000, priority: 1 },
  { name: "Velociraptor", weight: 100, priority: 2 },
  { name: "Triceratops", weight: 9000, priority: 3 },
  { name: "Gallimimus", weight: 450, priority: 4 }
];

// Sortowanie według priorytetu karmienia
dinosaurs.sort((a, b) => a.priority - b.priority);
console.log("Kolejność karmienia według priorytetu:");
dinosaurs.forEach(dino => console.log(`${dino.name} (priorytet: ${dino.priority})`));

// Sortowanie według wagi (od najcięższego)
dinosaurs.sort((a, b) => b.weight - a.weight);
console.log("\nKolejność według wagi (od najcięższego):");
dinosaurs.forEach(dino => console.log(`${dino.name} (${dino.weight} kg)`));

// Sortowanie alfabetycznie według nazwy
dinosaurs.sort((a, b) => a.name.localeCompare(b.name));
console.log("\nDinozaury alfabetycznie:");
dinosaurs.forEach(dino => console.log(`${dino.name}`));

Metoda sort() przyjmuje opcjonalną funkcję porównującą, która powinna zwrócić:

  • Wartość ujemną, jeśli a powinno być przed b
  • Zero, jeśli a i b są równoważne pod względem sortowania
  • Wartość dodatnią, jeśli a powinno być po b

Kiedy warto używać sort():

  • Gdy potrzebujesz uporządkować elementy tablicy według określonego kryterium
  • Gdy pracujesz z listami, które muszą być prezentowane w określonej kolejności
  • Gdy implementujesz funkcjonalność sortowania w aplikacji

7. reverse() - odwrócenie kolejności tablicy

Metoda reverse() odwraca kolejność elementów w tablicy i zwraca odwróconą tablicę:

// Lista dinozaurów od najstarszego do najmłodszego
const dinosaursByAge = ["Brachiosaurus", "Stegosaurus", "Triceratops", "Velociraptor", "T-Rex"];

// Odwrócenie kolejności, aby uzyskać listę od najmłodszego do najstarszego
dinosaursByAge.reverse();
console.log("Od najmłodszego do najstarszego:", dinosaursByAge);
// ["T-Rex", "Velociraptor", "Triceratops", "Stegosaurus", "Brachiosaurus"]

// Często używana w połączeniu z sort()
const dinoHeights = [500, 900, 200, 1200, 350];
// Sortowanie malejąco poprzez sortowanie rosnąco + odwrócenie
dinoHeights.sort((a, b) => a - b).reverse();
console.log("Wysokości malejąco:", dinoHeights);
// [1200, 900, 500, 350, 200]

Kiedy warto używać reverse():

  • Gdy potrzebujesz odwrócić kolejność elementów w tablicy
  • Gdy chcesz zmienić porządek z rosnącego na malejący (lub odwrotnie) po sortowaniu
  • Gdy implementujesz funkcjonalność "odwróć kolejność" w interfejsie użytkownika

8. fill() - wypełnianie tablicy wartością

Metoda fill() wypełnia wszystkie elementy tablicy od indeksu startowego do indeksu końcowego (nie wliczając) określoną wartością:

// Przygotowanie tablicy na pomiary temperatury dinozaurów (10 pomiarów)
const temperatures = new Array(10);

// Wypełnienie domyślną wartością (38.5 stopni Celsjusza)
temperatures.fill(38.5);
console.log("Domyślne temperatury:", temperatures);
// [38.5, 38.5, 38.5, 38.5, 38.5, 38.5, 38.5, 38.5, 38.5, 38.5]

// Wypełnienie tylko części tablicy
temperatures.fill(39.2, 2, 5); // Od indeksu 2 (włącznie) do 5 (wyłączając)
console.log("Zaktualizowane temperatury:", temperatures);
// [38.5, 38.5, 39.2, 39.2, 39.2, 38.5, 38.5, 38.5, 38.5, 38.5]

// Użycie z nową tablicą i indeksami ujemnymi (liczone od końca)
const feedingSchedule = new Array(7).fill("Standardowe");
feedingSchedule.fill("Zwiększona porcja", -3); // Ostatnie 3 dni
console.log("Plan karmienia na tydzień:", feedingSchedule);
// ["Standardowe", "Standardowe", "Standardowe", "Standardowe", "Zwiększona porcja", "Zwiększona porcja", "Zwiększona porcja"]

Kiedy warto używać fill():

  • Gdy tworzysz nową tablicę i potrzebujesz wypełnić ją określoną wartością początkową
  • Gdy potrzebujesz zastąpić wszystkie lub niektóre wartości w istniejącej tablicy
  • Gdy inicjalizujesz tablice do przechowywania danych z domyślnymi wartościami

Zastosowanie podstawowych metod tablic w praktyce

Teraz połączmy poznane metody, aby rozwiązać bardziej praktyczne scenariusze w naszym Parku Jurajskim:

Przykład 1: System zarządzania karmą dla dinozaurów

// System zarządzania karmą dla dinozaurów
const feedingSystem = {
  // Stan systemu
  foodInventory: [],
  feedingQueue: [],
  feedingHistory: [],

  // Dodawanie nowego zapasu karmy
  addFoodSupply: function(type, quantity, expirationDate) {
    const supply = { type, quantity, expirationDate, addedOn: new Date() };
    this.foodInventory.push(supply);

    // Sortowanie według daty ważności (najkrótszej)
    this.foodInventory.sort((a, b) =>
      new Date(a.expirationDate) - new Date(b.expirationDate)
    );

    console.log(`Dodano ${quantity}kg karmy typu "${type}" do zapasów.`);
    return supply;
  },

  // Dodawanie dinozaura do kolejki karmienia
  scheduleDinoFeeding: function(dinoId, dinoName, foodType, quantity, priority) {
    const feedingRequest = {
      dinoId,
      dinoName,
      foodType,
      quantity,
      priority,
      scheduledAt: new Date()
    };

    if (priority === "high") {
      // Dodaj na początek kolejki
      this.feedingQueue.unshift(feedingRequest);
    } else {
      // Dodaj na koniec kolejki
      this.feedingQueue.push(feedingRequest);
    }

    console.log(`Zaplanowano karmienie dla ${dinoName} (priorytet: ${priority})`);
    return this.feedingQueue.length;
  },

  // Pobieranie następnego dinozaura do nakarmienia
  getNextDinoToFeed: function() {
    if (this.feedingQueue.length === 0) {
      console.log("Wszystkie dinozaury nakarmione. Kolejka pusta.");
      return null;
    }

    const nextFeeding = this.feedingQueue.shift();
    console.log(`Następny do karmienia: ${nextFeeding.dinoName}`);
    return nextFeeding;
  },

  // Wydawanie karmy ze spichlerza
  dispenseFoodForDino: function(dinoFeeding) {
    const { foodType, quantity, dinoName } = dinoFeeding;

    // Szukanie odpowiedniego zapasu karmy
    let remainingQuantity = quantity;
    const usedSupplies = [];

    // Iterujemy od najstarszego zapasu (który wygasa najszybciej)
    for (let i = 0; i < this.foodInventory.length && remainingQuantity > 0; i++) {
      const supply = this.foodInventory[i];

      if (supply.type === foodType && supply.quantity > 0) {
        // Ile możemy pobrać z tego zapasu
        const amountToTake = Math.min(remainingQuantity, supply.quantity);
        supply.quantity -= amountToTake;
        remainingQuantity -= amountToTake;

        usedSupplies.push({
          type: supply.type,
          amount: amountToTake,
          expirationDate: supply.expirationDate
        });

        // Jeśli zapas się skończył, usuwamy go z inwentarza
        if (supply.quantity === 0) {
          this.foodInventory.splice(i, 1);
          i--; // Dostosuj indeks po usunięciu elementu
        }
      }
    }

    // Dodaj rekord do historii karmienia
    const feedingRecord = {
      ...dinoFeeding,
      fedAt: new Date(),
      suppliesUsed: usedSupplies,
      fullyFed: remainingQuantity === 0
    };

    this.feedingHistory.push(feedingRecord);

    if (remainingQuantity > 0) {
      console.log(`UWAGA: Brakuje ${remainingQuantity}kg karmy typu "${foodType}" dla ${dinoName}!`);
      return false;
    }

    console.log(`Nakarmiono ${dinoName} używając ${quantity}kg karmy typu "${foodType}".`);
    return feedingRecord;
  },

  // Przeprowadzenie pełnego procesu karmienia
  processFeedingCycle: function(maxFeedings = 5) {
    console.log("=== ROZPOCZĘCIE CYKLU KARMIENIA ===");
    let feedingsProcessed = 0;

    // Przetwarzamy określoną liczbę karmień lub dopóki kolejka się nie opróżni
    while (feedingsProcessed < maxFeedings && this.feedingQueue.length > 0) {
      const nextDino = this.getNextDinoToFeed();

      if (nextDino) {
        const result = this.dispenseFoodForDino(nextDino);

        if (!result) {
          // Jeśli nie udało się nakarmić, przenosimy dinozaura na koniec kolejki
          this.feedingQueue.push({
            ...nextDino,
            priority: "high", // Podnosimy priorytet dla nienakarmionego dinozaura
            scheduledAt: new Date()
          });
          console.log(`${nextDino.dinoName} przesunięty na koniec kolejki z wysokim priorytetem.`);
        }

        feedingsProcessed++;
      }
    }

    console.log(`=== ZAKOŃCZENIE CYKLU KARMIENIA (przetworzono: ${feedingsProcessed}) ===`);
    console.log(`Pozostało w kolejce: ${this.feedingQueue.length} dinozaurów`);
    return feedingsProcessed;
  },

  // Raportowanie stanu zapasów
  reportInventoryStatus: function() {
    console.log("=== RAPORT STANU ZAPASÓW ===");

    if (this.foodInventory.length === 0) {
      console.log("Magazyn jest pusty! Zamów nowe zapasy karmy!");
      return { isEmpty: true, totalQuantity: 0, types: [] };
    }

    // Grupowanie zapasów według typu
    const inventory = this.foodInventory.reduce((acc, supply) => {
      if (!acc[supply.type]) {
        acc[supply.type] = 0;
      }
      acc[supply.type] += supply.quantity;
      return acc;
    }, {});

    // Obliczanie łącznej ilości
    const totalQuantity = Object.values(inventory).reduce((sum, qty) => sum + qty, 0);

    console.log(`Łączna ilość karmy: ${totalQuantity}kg`);
    Object.entries(inventory).forEach(([type, qty]) => {
      console.log(`- ${type}: ${qty}kg`);
    });

    // Sprawdzenie zapasów, które wkrótce wygasną (w ciągu 3 dni)
    const today = new Date();
    const threeDaysLater = new Date(today);
    threeDaysLater.setDate(today.getDate() + 3);

    const expiringSupplies = this.foodInventory.filter(supply =>
      new Date(supply.expirationDate) <= threeDaysLater
    );

    if (expiringSupplies.length > 0) {
      console.log("\nZapasy wygasające w ciągu 3 dni:");
      expiringSupplies.forEach(supply => {
        console.log(`- ${supply.quantity}kg ${supply.type} (wygasa: ${supply.expirationDate})`);
      });
    }

    return {
      isEmpty: false,
      totalQuantity,
      types: Object.keys(inventory),
      inventory,
      expiringSupplies
    };
  }
};

// Demonstracja działania systemu
console.log("=== DEMONSTRACJA SYSTEMU ZARZĄDZANIA KARMĄ ===");

// 1. Dodawanie zapasów karmy
feedingSystem.addFoodSupply("Mięso", 500, "2023-07-15");
feedingSystem.addFoodSupply("Rośliny", 800, "2023-07-10");
feedingSystem.addFoodSupply("Ryby", 200, "2023-07-05");
feedingSystem.addFoodSupply("Mięso", 300, "2023-07-20");

// 2. Planowanie karmienia
feedingSystem.scheduleDinoFeeding("TRX-01", "Rex", "Mięso", 150, "high");
feedingSystem.scheduleDinoFeeding("VEL-02", "Blue", "Mięso", 50, "normal");
feedingSystem.scheduleDinoFeeding("TRCP-03", "Trixie", "Rośliny", 120, "normal");
feedingSystem.scheduleDinoFeeding("BRCH-04", "Bronty", "Rośliny", 250, "normal");
feedingSystem.scheduleDinoFeeding("STEG-05", "Spike", "Rośliny", 100, "high");

// 3. Raport stanu zapasów przed karmieniem
feedingSystem.reportInventoryStatus();

// 4. Przeprowadzanie cyklu karmienia
feedingSystem.processFeedingCycle(3); // Przetwarzamy tylko 3 karmienia

// 5. Sprawdzamy stan zapasów po karmieniu
feedingSystem.reportInventoryStatus();

// 6. Dokończenie cyklu karmienia
feedingSystem.processFeedingCycle(5); // Przetwarzamy pozostałe karmienia

// 7. Sprawdzamy stan zapasów po pełnym cyklu
feedingSystem.reportInventoryStatus();

Przykład 2: Zarządzanie zespołami pracowników parku

// System zarządzania zespołami pracowników Parku Jurajskiego
const staffManagementSystem = {
  // Dane systemu
  departments: [
    { id: "OPS", name: "Operacje" },
    { id: "SCI", name: "Badania naukowe" },
    { id: "SEC", name: "Bezpieczeństwo" },
    { id: "VET", name: "Weterynaria" },
    { id: "MAINT", name: "Konserwacja" }
  ],
  staff: [],
  teams: [],

  // Dodawanie nowego pracownika
  addStaffMember: function(name, role, skills, departmentId) {
    // Sprawdzenie, czy dział istnieje
    const department = this.departments.find(dept => dept.id === departmentId);
    if (!department) {
      console.log(`Błąd: Dział o ID "${departmentId}" nie istnieje.`);
      return null;
    }

    // Generowanie ID pracownika
    const id = `${departmentId}-${(this.staff.length + 1).toString().padStart(3, '0')}`;

    const staffMember = {
      id,
      name,
      role,
      skills: Array.isArray(skills) ? skills : [skills],
      departmentId,
      departmentName: department.name,
      hireDate: new Date().toISOString().split('T')[0]
    };

    this.staff.push(staffMember);
    console.log(`Dodano pracownika: ${name} (${role}) do działu ${department.name}`);

    return staffMember;
  },

  // Utworzenie nowego zespołu
  createTeam: function(name, mission, leaderId) {
    // Sprawdzenie, czy leader istnieje
    const leader = this.staff.find(person => person.id === leaderId);
    if (!leader) {
      console.log(`Błąd: Pracownik o ID "${leaderId}" nie istnieje.`);
      return null;
    }

    const teamId = `TEAM-${(this.teams.length + 1).toString().padStart(3, '0')}`;

    const team = {
      id: teamId,
      name,
      mission,
      createdAt: new Date().toISOString().split('T')[0],
      leaderId,
      leaderName: leader.name,
      members: [leaderId],
      status: "active"
    };

    this.teams.push(team);
    console.log(`Utworzono zespół: ${name} (misja: ${mission}), prowadzący: ${leader.name}`);

    return team;
  },

  // Dodawanie pracownika do zespołu
  addMemberToTeam: function(teamId, memberId) {
    // Znajdź zespół
    const teamIndex = this.teams.findIndex(team => team.id === teamId);
    if (teamIndex === -1) {
      console.log(`Błąd: Zespół o ID "${teamId}" nie istnieje.`);
      return false;
    }

    // Znajdź pracownika
    const member = this.staff.find(person => person.id === memberId);
    if (!member) {
      console.log(`Błąd: Pracownik o ID "${memberId}" nie istnieje.`);
      return false;
    }

    // Sprawdź, czy pracownik już jest w zespole
    if (this.teams[teamIndex].members.includes(memberId)) {
      console.log(`${member.name} już jest członkiem zespołu ${this.teams[teamIndex].name}.`);
      return false;
    }

    // Dodaj pracownika do zespołu
    this.teams[teamIndex].members.push(memberId);
    console.log(`Dodano ${member.name} do zespołu ${this.teams[teamIndex].name}.`);

    return true;
  },

  // Usunięcie pracownika z zespołu
  removeMemberFromTeam: function(teamId, memberId) {
    // Znajdź zespół
    const teamIndex = this.teams.findIndex(team => team.id === teamId);
    if (teamIndex === -1) {
      console.log(`Błąd: Zespół o ID "${teamId}" nie istnieje.`);
      return false;
    }

    // Sprawdź, czy pracownik jest liderem
    if (this.teams[teamIndex].leaderId === memberId) {
      console.log(`Błąd: Nie można usunąć lidera zespołu. Najpierw zmień lidera.`);
      return false;
    }

    // Znajdź indeks pracownika w zespole
    const memberIndex = this.teams[teamIndex].members.indexOf(memberId);
    if (memberIndex === -1) {
      console.log(`Pracownik nie jest członkiem zespołu ${this.teams[teamIndex].name}.`);
      return false;
    }

    // Znajdź pracownika dla celów informacyjnych
    const member = this.staff.find(person => person.id === memberId);

    // Usuń pracownika z zespołu
    this.teams[teamIndex].members.splice(memberIndex, 1);
    console.log(`Usunięto ${member ? member.name : memberId} z zespołu ${this.teams[teamIndex].name}.`);

    return true;
  },

  // Zmiana lidera zespołu
  changeTeamLeader: function(teamId, newLeaderId) {
    // Znajdź zespół
    const teamIndex = this.teams.findIndex(team => team.id === teamId);
    if (teamIndex === -1) {
      console.log(`Błąd: Zespół o ID "${teamId}" nie istnieje.`);
      return false;
    }

    // Sprawdź, czy nowy lider istnieje
    const newLeader = this.staff.find(person => person.id === newLeaderId);
    if (!newLeader) {
      console.log(`Błąd: Pracownik o ID "${newLeaderId}" nie istnieje.`);
      return false;
    }

    // Sprawdź, czy nowy lider jest członkiem zespołu
    if (!this.teams[teamIndex].members.includes(newLeaderId)) {
      // Dodaj nowego lidera do zespołu, jeśli jeszcze nie jest członkiem
      this.teams[teamIndex].members.push(newLeaderId);
      console.log(`${newLeader.name} został dodany do zespołu jako nowy lider.`);
    }

    // Zapisz informacje o starym liderze dla komunikatu
    const oldLeaderId = this.teams[teamIndex].leaderId;
    const oldLeader = this.staff.find(person => person.id === oldLeaderId);

    // Zaktualizuj lidera
    this.teams[teamIndex].leaderId = newLeaderId;
    this.teams[teamIndex].leaderName = newLeader.name;

    console.log(`Lider zespołu ${this.teams[teamIndex].name} zmieniony z ${oldLeader.name} na ${newLeader.name}.`);
    return true;
  },

  // Rozwiązanie zespołu
  deactivateTeam: function(teamId, reason) {
    // Znajdź zespół
    const teamIndex = this.teams.findIndex(team => team.id === teamId);
    if (teamIndex === -1) {
      console.log(`Błąd: Zespół o ID "${teamId}" nie istnieje.`);
      return false;
    }

    // Zapisanie stanu przed modyfikacją
    const teamName = this.teams[teamIndex].name;

    // Aktualizacja statusu zespołu
    this.teams[teamIndex].status = "inactive";
    this.teams[teamIndex].deactivatedAt = new Date().toISOString().split('T')[0];
    this.teams[teamIndex].deactivationReason = reason || "Nieokreślony";

    console.log(`Zespół ${teamName} został dezaktywowany. Powód: ${this.teams[teamIndex].deactivationReason}`);
    return true;
  },

  // Generowanie raportu o zespołach
  generateTeamsReport: function(includeInactive = false) {
    console.log("=== RAPORT O ZESPOŁACH PARKU JURAJSKIEGO ===");

    // Filtruj zespoły według statusu, jeśli nie uwzględniamy nieaktywnych
    const teamsToReport = includeInactive
      ? this.teams
      : this.teams.filter(team => team.status === "active");

    if (teamsToReport.length === 0) {
      console.log("Brak zespołów do wyświetlenia.");
      return { teams: [] };
    }

    // Przygotowanie danych do raportu
    const teamsData = teamsToReport.map(team => {
      // Pobierz pełne informacje o członkach
      const memberDetails = team.members.map(memberId => {
        const member = this.staff.find(person => person.id === memberId);
        return member ? {
          id: member.id,
          name: member.name,
          role: member.role,
          isLeader: memberId === team.leaderId
        } : { id: memberId, name: "Nieznany", role: "Nieznany", isLeader: false };
      });

      return {
        id: team.id,
        name: team.name,
        mission: team.mission,
        status: team.status,
        memberCount: team.members.length,
        leader: this.staff.find(person => person.id === team.leaderId),
        members: memberDetails,
        createdAt: team.createdAt,
        deactivatedAt: team.deactivatedAt,
        deactivationReason: team.deactivationReason
      };
    });

    // Sortuj zespoły - aktywne pierwsze, potem według daty utworzenia
    teamsData.sort((a, b) => {
      if (a.status !== b.status) {
        return a.status === "active" ? -1 : 1;
      }
      return new Date(b.createdAt) - new Date(a.createdAt);
    });

    // Wyświetl podsumowanie
    console.log(`Liczba zespołów: ${teamsData.length}`);
    console.log(`Aktywne zespoły: ${teamsData.filter(t => t.status === "active").length}`);
    if (includeInactive) {
      console.log(`Nieaktywne zespoły: ${teamsData.filter(t => t.status === "inactive").length}`);
    }

    // Wyświetl szczegóły dla każdego zespołu
    teamsData.forEach(team => {
      console.log(`\n${team.id}: ${team.name} (Status: ${team.status})`);
      console.log(`Misja: ${team.mission}`);
      console.log(`Lider: ${team.leader ? team.leader.name : 'Brak'} (${team.leader ? team.leader.role : ''})`);
      console.log(`Liczba członków: ${team.memberCount}`);
      console.log("Członkowie:");
      team.members.forEach(member => {
        console.log(`  - ${member.name} (${member.role})${member.isLeader ? ' [LIDER]' : ''}`);
      });

      if (team.status === "inactive") {
        console.log(`Dezaktywowano: ${team.deactivatedAt}`);
        console.log(`Powód: ${team.deactivationReason}`);
      }
    });

    return { teams: teamsData };
  },

  // Reorganizacja zespołów
  reorganizeTeams: function(fromTeamId, toTeamId, memberIds, dissolveSourceTeam = false) {
    // Sprawdź, czy zespoły istnieją
    const fromTeamIndex = this.teams.findIndex(team => team.id === fromTeamId);
    const toTeamIndex = this.teams.findIndex(team => team.id === toTeamId);

    if (fromTeamIndex === -1 || toTeamIndex === -1) {
      console.log(`Błąd: Jeden lub oba zespoły nie istnieją.`);
      return false;
    }

    // Sprawdź, czy zespoły są aktywne
    if (this.teams[fromTeamIndex].status !== "active" || this.teams[toTeamIndex].status !== "active") {
      console.log(`Błąd: Zespoły muszą być aktywne, aby je reorganizować.`);
      return false;
    }

    // Jeśli nie podano konkretnych członków, przenieś wszystkich (oprócz lidera)
    const membersToMove = memberIds ||
      this.teams[fromTeamIndex].members.filter(id => id !== this.teams[fromTeamIndex].leaderId);

    // Przenieś członków
    for (const memberId of membersToMove) {
      // Sprawdź, czy pracownik jest częścią źródłowego zespołu
      if (!this.teams[fromTeamIndex].members.includes(memberId)) {
        console.log(`Błąd: Pracownik o ID ${memberId} nie jest członkiem zespołu źródłowego.`);
        continue;
      }

      // Sprawdź, czy pracownik nie jest liderem (jeśli nie chcemy przenosić wszystkich)
      if (memberIds && memberId === this.teams[fromTeamIndex].leaderId) {
        console.log(`Nie można przenieść lidera zespołu. Najpierw zmień lidera.`);
        continue;
      }

      // Sprawdź, czy pracownik już jest częścią docelowego zespołu
      if (this.teams[toTeamIndex].members.includes(memberId)) {
        console.log(`Pracownik o ID ${memberId} już jest członkiem zespołu docelowego.`);
        continue;
      }

      // Usuń z pierwotnego zespołu
      const fromIndex = this.teams[fromTeamIndex].members.indexOf(memberId);
      this.teams[fromTeamIndex].members.splice(fromIndex, 1);

      // Dodaj do nowego zespołu
      this.teams[toTeamIndex].members.push(memberId);

      // Znajdź nazwę pracownika dla logów
      const member = this.staff.find(person => person.id === memberId);
      console.log(`Przeniesiono ${member ? member.name : memberId} z zespołu ${this.teams[fromTeamIndex].name} do ${this.teams[toTeamIndex].name}`);
    }

    // Jeśli wybrano rozwiązanie źródłowego zespołu i nie ma już członków
    if (dissolveSourceTeam || this.teams[fromTeamIndex].members.length === 0) {
      this.deactivateTeam(fromTeamId, "Reorganizacja - zespół przeniesiony");
    }

    return true;
  }
};

// Demonstracja działania systemu zarządzania zespołami
console.log("=== DEMONSTRACJA SYSTEMU ZARZĄDZANIA ZESPOŁAMI ===");

// 1. Dodawanie pracowników
const owen = staffManagementSystem.addStaffMember("Owen Grady", "Trener dinozaurów", ["Zachowania zwierząt", "Tresura", "Pierwsza pomoc"], "OPS");
const claire = staffManagementSystem.addStaffMember("Claire Dearing", "Dyrektor operacyjny", ["Zarządzanie", "Marketing", "Administracja"], "OPS");
const dr_wu = staffManagementSystem.addStaffMember("Dr. Henry Wu", "Główny genetyk", ["Genetyka", "Bioinżynieria", "Klonowanie"], "SCI");
const barry = staffManagementSystem.addStaffMember("Barry", "Asystent trenera", ["Tresura", "Opieka nad zwierzętami"], "OPS");
const lowery = staffManagementSystem.addStaffMember("Lowery Cruthers", "Technik systemów", ["IT", "Monitoring", "Komunikacja"], "SEC");
const vivian = staffManagementSystem.addStaffMember("Vivian Krill", "Koordynator bezpieczeństwa", ["Bezpieczeństwo", "Komunikacja", "Zarządzanie kryzysowe"], "SEC");
const muldoon = staffManagementSystem.addStaffMember("Robert Muldoon", "Specjalista ds. bezpieczeństwa", ["Broń", "Bezpieczeństwo", "Tropienie"], "SEC");
const malcolm = staffManagementSystem.addStaffMember("Dr. Ian Malcolm", "Matematyk", ["Teoria chaosu", "Analiza ryzyka", "Modelowanie"], "SCI");
const sattler = staffManagementSystem.addStaffMember("Dr. Ellie Sattler", "Paleobotanik", ["Botanika", "Paleontologia", "Ekologia"], "SCI");
const harding = staffManagementSystem.addStaffMember("Dr. Gerry Harding", "Weterynarz", ["Weterynaria", "Zoologia", "Medycyna"], "VET");

// 2. Tworzenie zespołów
const raptorTeam = staffManagementSystem.createTeam("Zespół Velociraptor", "Tresura i opieka nad Velociraptorami", owen.id);
staffManagementSystem.addMemberToTeam(raptorTeam.id, barry.id);

const securityTeam = staffManagementSystem.createTeam("Zespół Bezpieczeństwa", "Zapewnienie bezpieczeństwa w parku", muldoon.id);
staffManagementSystem.addMemberToTeam(securityTeam.id, vivian.id);
staffManagementSystem.addMemberToTeam(securityTeam.id, lowery.id);

const scienceTeam = staffManagementSystem.createTeam("Zespół Naukowy", "Badania naukowe i rozwój", dr_wu.id);
staffManagementSystem.addMemberToTeam(scienceTeam.id, malcolm.id);
staffManagementSystem.addMemberToTeam(scienceTeam.id, sattler.id);

// 3. Raport o zespołach
staffManagementSystem.generateTeamsReport();

// 4. Reorganizacja zespołów
console.log("\n=== REORGANIZACJA ZESPOŁÓW ===");

// Tworzenie nowego zespołu zarządzania kryzysowego
const crisisTeam = staffManagementSystem.createTeam("Zespół Zarządzania Kryzysowego", "Reagowanie na sytuacje kryzysowe", claire.id);

// Przenoszenie członków z innych zespołów
staffManagementSystem.reorganizeTeams(securityTeam.id, crisisTeam.id, [vivian.id]);
staffManagementSystem.addMemberToTeam(crisisTeam.id, malcolm.id); // Dodajemy Malcolma jako doradcę ds. ryzyka
staffManagementSystem.addMemberToTeam(crisisTeam.id, harding.id);  // Dodajemy weterynarza

// Zmiana lidera zespołu naukowego
staffManagementSystem.changeTeamLeader(scienceTeam.id, sattler.id);

// Dezaktywacja jednego zespołu
staffManagementSystem.deactivateTeam(raptorTeam.id, "Projekt zawieszony - incydent z raptorami");

// 5. Finalny raport o zespołach (z uwzględnieniem nieaktywnych)
staffManagementSystem.generateTeamsReport(true);

Podsumowanie

W tej lekcji poznaliśmy podstawowe metody modyfikacji tablic w JavaScript:

  1. push() - dodaje elementy na końcu tablicy
  2. pop() - usuwa i zwraca ostatni element tablicy
  3. unshift() - dodaje elementy na początku tablicy
  4. shift() - usuwa i zwraca pierwszy element tablicy
  5. splice() - dodaje, usuwa lub zastępuje elementy w dowolnym miejscu tablicy
  6. sort() - sortuje elementy tablicy
  7. reverse() - odwraca kolejność elementów w tablicy
  8. fill() - wypełnia elementy tablicy określoną wartością

Umiejętność efektywnego wykorzystania tych metod jest kluczowa przy pracy z danymi w JavaScript. Pozwalają one na zarządzanie kolekcjami, implementowanie struktur danych (takich jak stosy i kolejki) oraz efektywną manipulację danymi.

Warto pamiętać, że powyższe metody modyfikują oryginalną tablicę (z wyjątkiem przypadków, gdy tworzymy kopię przed ich zastosowaniem). W jednej z kolejnych lekcji poznamy metody tablic, które nie modyfikują oryginału, ale zwracają nową tablicę lub wartość.

Kod do tej lekcji: index.js
// Metody tablic - Park Jurajski
console.log("Laboratorium Metod Tablic");
console.log("Zaawansowane operacje na kolekcjach\n");

// ===========================================
// 1. forEach() - ITERACJA
// ===========================================
console.log("=== 1. forEach() - Iteracja ===");

const dinosaurs = ["T-Rex", "Velociraptor", "Triceratops", "Stegosaurus"];

console.log("\nLista dinozaurów:");
dinosaurs.forEach((dino, index) => {
  console.log(`  ${index + 1}. ${dino}`);
});

// forEach z pełnymi parametrami
console.log("\nPełna wersja forEach:");
dinosaurs.forEach((element, index, array) => {
  console.log(`  [${index}] ${element} z tablicy długości ${array.length}`);
});

// ===========================================
// 2. map() - TRANSFORMACJA
// ===========================================
console.log("\n=== 2. map() - Transformacja ===");

const dinoData = [
  { name: "T-Rex", weight: 8000 },
  { name: "Velociraptor", weight: 80 },
  { name: "Triceratops", weight: 9000 }
];

// Wyciągnięcie samych nazw
const names = dinoData.map(dino => dino.name);
console.log("\nSame nazwy:", names);

// Transformacja do nowego formatu
const formatted = dinoData.map(dino => ({
  species: dino.name,
  weightInTons: dino.weight / 1000,
  category: dino.weight > 1000 ? "Duży" : "Mały"
}));

console.log("\nPrzetransformowane:");
formatted.forEach(d => {
  console.log(`  ${d.species}: ${d.weightInTons}t - ${d.category}`);
});

// ===========================================
// 3. filter() - FILTROWANIE
// ===========================================
console.log("\n=== 3. filter() - Filtrowanie ===");

const allDinos = [
  { name: "T-Rex", weight: 8000, carnivore: true },
  { name: "Velociraptor", weight: 80, carnivore: true },
  { name: "Triceratops", weight: 9000, carnivore: false },
  { name: "Stegosaurus", weight: 5000, carnivore: false },
  { name: "Brachiosaurus", weight: 50000, carnivore: false }
];

// Tylko mięsożercy
const carnivores = allDinos.filter(dino => dino.carnivore);
console.log("\nMięsożercy:", carnivores.map(d => d.name));

// Ciężkie dinozaury (> 5000kg)
const heavy = allDinos.filter(dino => dino.weight > 5000);
console.log("Ciężkie (>5t):", heavy.map(d => d.name));

// Łączenie warunków
const heavyCarnivores = allDinos.filter(d => d.carnivore && d.weight > 100);
console.log("Ciężkie mięsożercy:", heavyCarnivores.map(d => d.name));

// ===========================================
// 4. find() i findIndex()
// ===========================================
console.log("\n=== 4. find() i findIndex() ===");

const park = [
  { id: 1, name: "T-Rex", sector: "A" },
  { id: 2, name: "Velociraptor", sector: "B" },
  { id: 3, name: "Triceratops", sector: "C" }
];

// find() - pierwszy element spełniający warunek
const foundDino = park.find(dino => dino.sector === "B");
console.log("\nfind(sector === 'B'):", foundDino);

// findIndex() - indeks pierwszego elementu
const foundIndex = park.findIndex(dino => dino.name === "Triceratops");
console.log("findIndex(name === 'Triceratops'):", foundIndex);

// Nieznaleziony element
const notFound = park.find(dino => dino.name === "Pteranodon");
console.log("find(Pteranodon):", notFound); // undefined

// ===========================================
// 5. reduce() - AGREGACJA
// ===========================================
console.log("\n=== 5. reduce() - Agregacja ===");

const weights = [
  { name: "T-Rex", weight: 8000 },
  { name: "Velociraptor", weight: 80 },
  { name: "Triceratops", weight: 9000 },
  { name: "Stegosaurus", weight: 5000 }
];

// Suma wag
const totalWeight = weights.reduce((sum, dino) => sum + dino.weight, 0);
console.log(`\nŁączna waga: ${totalWeight}kg`);

// Średnia waga
const avgWeight = totalWeight / weights.length;
console.log(`Średnia waga: ${avgWeight.toFixed(2)}kg`);

// Grupowanie po wadze
const grouped = weights.reduce((acc, dino) => {
  const category = dino.weight > 1000 ? "heavy" : "light";
  if (!acc[category]) acc[category] = [];
  acc[category].push(dino.name);
  return acc;
}, {});

console.log("\nPogrupowane:");
console.log("  Ciężkie:", grouped.heavy);
console.log("  Lekkie:", grouped.light);

// Znajdowanie max
const heaviest = weights.reduce((max, dino) =>
  dino.weight > max.weight ? dino : max
);
console.log(`\nNajcięższy: ${heaviest.name} (${heaviest.weight}kg)`);

// ===========================================
// 6. some() i every()
// ===========================================
console.log("\n=== 6. some() i every() ===");

const herd = [
  { name: "Trike", health: 95 },
  { name: "Stego", health: 88 },
  { name: "Brachio", health: 72 }
];

// some() - czy przynajmniej jeden
const hasSick = herd.some(dino => dino.health < 80);
console.log("\nCzy są chore (<80%):", hasSick);

const hasHealthy = herd.some(dino => dino.health > 90);
console.log("Czy są bardzo zdrowe (>90%):", hasHealthy);

// every() - czy wszystkie
const allHealthy = herd.every(dino => dino.health >= 80);
console.log("Czy wszystkie zdrowe (≥80%):", allHealthy);

const allCritical = herd.every(dino => dino.health < 50);
console.log("Czy wszystkie krytyczne (<50%):", allCritical);

// ===========================================
// 7. sort() - SORTOWANIE
// ===========================================
console.log("\n=== 7. sort() - Sortowanie ===");

const unsorted = ["Velociraptor", "T-Rex", "Brachiosaurus", "Stegosaurus"];

// Alfabetycznie
const alphabetical = [...unsorted].sort();
console.log("\nAlfabetycznie:", alphabetical);

// Odwrotnie alfabetycznie
const reverseAlpha = [...unsorted].sort((a, b) => b.localeCompare(a));
console.log("Odwrotnie:", reverseAlpha);

// Sortowanie obiektów
const dinoStats = [
  { name: "T-Rex", health: 85 },
  { name: "Velociraptor", health: 100 },
  { name: "Triceratops", health: 70 }
];

const byHealth = [...dinoStats].sort((a, b) => b.health - a.health);
console.log("\nPo zdrowiu (malejąco):");
byHealth.forEach(d => console.log(`  ${d.name}: ${d.health}%`));

// ===========================================
// 8. ŁAŃCUCHOWANIE METOD
// ===========================================
console.log("\n=== 8. Łańcuchowanie metod ===");

const inventory = [
  { name: "Rexy", species: "T-Rex", sector: "A", health: 95, carnivore: true },
  { name: "Blue", species: "Velociraptor", sector: "B", health: 100, carnivore: true },
  { name: "Charlie", species: "Velociraptor", sector: "B", health: 85, carnivore: true },
  { name: "Trike", species: "Triceratops", sector: "C", health: 70, carnivore: false },
  { name: "Stego", species: "Stegosaurus", sector: "C", health: 92, carnivore: false }
];

// Znajdź zdrowych mięsożerców i posortuj po nazwie
const healthyCarnivores = inventory
  .filter(d => d.carnivore)
  .filter(d => d.health >= 90)
  .map(d => d.name)
  .sort();

console.log("\nZdrowi mięsożercy (≥90%):", healthyCarnivores);

// Suma zdrowia roślinożerców
const herbivoreHealth = inventory
  .filter(d => !d.carnivore)
  .reduce((sum, d) => sum + d.health, 0);

console.log(`Suma zdrowia roślinożerców: ${herbivoreHealth}%`);

// ===========================================
// 9. flat() i flatMap()
// ===========================================
console.log("\n=== 9. flat() i flatMap() ===");

const sectors = [
  ["T-Rex", "Spinosaurus"],
  ["Velociraptor", "Dilophosaurus"],
  ["Triceratops", "Stegosaurus"]
];

// flat() - spłaszczenie zagnieżdżonej tablicy
const flatDinos = sectors.flat();
console.log("\nflat():", flatDinos);

// flatMap() - map + flat w jednym
const withEmoji = sectors.flatMap(sector =>
  sector.map(dino => `${dino}`)
);
console.log("flatMap():", withEmoji);

// ===========================================
// 10. PRZYKŁAD KOMPLEKSOWY
// ===========================================
console.log("\n=== 10. System analizy - przykład kompleksowy ===");

class DinosaurAnalytics {
  constructor(dinosaurs) {
    this.dinosaurs = dinosaurs;
  }

  // Statystyki ogólne
  getOverallStats() {
    const total = this.dinosaurs.length;
    const avgHealth = this.dinosaurs.reduce((sum, d) => sum + d.health, 0) / total;
    const carnivoreCount = this.dinosaurs.filter(d => d.carnivore).length;

    return {
      total,
      avgHealth: avgHealth.toFixed(1),
      carnivores: carnivoreCount,
      herbivores: total - carnivoreCount
    };
  }

  // Top N po zdrowiu
  getHealthiest(n = 3) {
    return this.dinosaurs
      .sort((a, b) => b.health - a.health)
      .slice(0, n)
      .map(d => ({ name: d.name, health: d.health }));
  }

  // Grupowanie po sektorze
  groupBySector() {
    return this.dinosaurs.reduce((acc, dino) => {
      if (!acc[dino.sector]) acc[dino.sector] = [];
      acc[dino.sector].push(dino.name);
      return acc;
    }, {});
  }

  // Alerty dla chorych
  getHealthAlerts() {
    return this.dinosaurs
      .filter(d => d.health < 80)
      .map(d => ({
        name: d.name,
        sector: d.sector,
        health: d.health,
        priority: d.health < 50 ? "KRYTYCZNY" : "UWAGA"
      }))
      .sort((a, b) => a.health - b.health);
  }

  // Raport sektora
  getSectorReport(sector) {
    const dinosInSector = this.dinosaurs.filter(d => d.sector === sector);

    if (dinosInSector.length === 0) {
      return { error: `Brak dinozaurów w sektorze ${sector}` };
    }

    const avgHealth = dinosInSector.reduce((sum, d) => sum + d.health, 0) / dinosInSector.length;
    const carnivores = dinosInSector.filter(d => d.carnivore);
    const herbivores = dinosInSector.filter(d => !d.carnivore);

    return {
      sector,
      total: dinosInSector.length,
      avgHealth: avgHealth.toFixed(1),
      carnivores: carnivores.map(d => d.name),
      herbivores: herbivores.map(d => d.name),
      list: dinosInSector.map(d => `${d.name} (${d.health}%)`)
    };
  }

  // Wyświetl wszystkie analizy
  displayFullReport() {
    console.log("\nPEŁNY RAPORT ANALITYCZNY");
    console.log("=".repeat(70));

    // Statystyki ogólne
    const stats = this.getOverallStats();
    console.log("\nStatystyki ogólne:");
    console.log(`   Łącznie dinozaurów: ${stats.total}`);
    console.log(`   Średnie zdrowie: ${stats.avgHealth}%`);
    console.log(`   Mięsożercy: ${stats.carnivores}`);
    console.log(`   Roślinożercy: ${stats.herbivores}`);

    // Najzdrowsze
    const healthiest = this.getHealthiest(3);
    console.log("\nTOP 3 - Najzdrowsze:");
    healthiest.forEach((d, i) => {
      console.log(`   ${i + 1}. ${d.name} - ${d.health}%`);
    });

    // Podział na sektory
    const sectors = this.groupBySector();
    console.log("\nPodział na sektory:");
    Object.entries(sectors).sort().forEach(([sector, dinos]) => {
      console.log(`   Sektor ${sector}: ${dinos.join(", ")}`);
    });

    // Alerty zdrowotne
    const alerts = this.getHealthAlerts();
    if (alerts.length > 0) {
      console.log("\nALERTY ZDROWOTNE:");
      alerts.forEach(alert => {
        console.log(`   [${alert.priority}] ${alert.name} - Sektor ${alert.sector} - ${alert.health}%`);
      });
    } else {
      console.log("\nBrak alertów zdrowotnych");
    }

    // Raporty sektorów
    const uniqueSectors = [...new Set(this.dinosaurs.map(d => d.sector))].sort();
    console.log("\nSZCZEGÓŁY SEKTORÓW:");
    uniqueSectors.forEach(sector => {
      const report = this.getSectorReport(sector);
      console.log(`\n   Sektor ${report.sector}:`);
      console.log(`     Dinozaury: ${report.total}`);
      console.log(`     Średnie zdrowie: ${report.avgHealth}%`);
      if (report.carnivores.length > 0) {
        console.log(`     Mięsożercy: ${report.carnivores.join(", ")}`);
      }
      if (report.herbivores.length > 0) {
        console.log(`     Roślinożercy: ${report.herbivores.join(", ")}`);
      }
    });
  }
}

// Dane testowe
const testData = [
  { name: "Rexy", species: "T-Rex", sector: "A", health: 95, carnivore: true },
  { name: "Blue", species: "Velociraptor", sector: "B", health: 100, carnivore: true },
  { name: "Charlie", species: "Velociraptor", sector: "B", health: 85, carnivore: true },
  { name: "Delta", species: "Velociraptor", sector: "B", health: 45, carnivore: true },
  { name: "Trike", species: "Triceratops", sector: "C", health: 70, carnivore: false },
  { name: "Stego", species: "Stegosaurus", sector: "C", health: 92, carnivore: false },
  { name: "Brachio", species: "Brachiosaurus", sector: "D", health: 88, carnivore: false }
];

// Uruchom analizę
const analytics = new DinosaurAnalytics(testData);
analytics.displayFullReport();

console.log("\nGratulacje! Opanowałeś metody tablic!");

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 Array.prototype.pop()?

  2. 2. Co zwróci typeof undefined?

  3. 3. Który sposób jest najprostszy do sprawdzenia wartości zmiennej podczas debugowania?

  4. 4. Dlaczego warto używać const zamiast let, gdy wartość zmiennej nie będzie zmieniana?

Zadania praktyczne w grze

  • Edytor kodu

    Utwórz tablicę species z gatunkami 'T-Rex', 'Velociraptor' i 'Triceratops'. Metodą push() dodaj na koniec 'Stegosaurus', a metodą shift() usuń pierwszy element i zapisz go w stałej removed. Wyświetl w konsoli tablicę species i jej długość (length).

  • Klikanie w kolejności

    Ułóż elementy template literal z interpolacją:

  • Edytor kodu

    Zapisz jako BigInt: const dinoEraStart = 245000000n (początek ery dinozaurów w latach temu) i const dinoEraEnd = 66000000n (jej koniec). Oblicz dinoEraDuration jako różnicę dinoEraStart - dinoEraEnd, a dinoEraDays jako dinoEraDuration pomnożone przez 365n. Wyświetl oba wyniki w konsoli.

  • Układanie w poziomie

    Ułóż elementy sprawdzania typu zmiennej:

  • Edytor kodu

    Utwórz stałą species z nazwą gatunku dinozaura zapisaną jako tekst, np. 'Tyrannosaurus Rex', i zmienną age (let) z wiekiem 25. Po urodzinach zmień wartość age na 26 i wyświetl w konsoli species i age.

  • Układanie w pionie

    Uporządkuj miejsca, w których JavaScript szuka zmiennej (scope chain):

  • Układanie w poziomie

    Ułóż elementy deklaracji funkcji strzałkowej (arrow function):

  • Edytor kodu

    Napisz funkcję ageInMillions(years), która zwraca wiek skamieniałości w milionach lat, zaokrąglony do liczby całkowitej przez Math.round(). Wywołaj ją dla skamieniałości sprzed 66000000 lat i wyświetl wynik w konsoli.

  • Klikanie w kolejności

    Uporządkuj proces alokacji pamięci dla zmiennych:

  • Układanie w pionie

    Uporządkuj kroki sprawdzania typu zmiennej w kodzie produkcyjnym:

  • Układanie w pionie

    Uporządkuj wprowadzenie nowych typów danych w JavaScript chronologicznie:

  • Klikanie w kolejności

    Ułóż elementy deklaracji tablicy w JavaScript

  • Układanie w pionie

    Uporządkuj etapy zarządzania pamięcią dla zmiennych w JavaScript:

  • Układanie w poziomie

    Ułóż elementy dodawania elementu do tablicy:

  1. Zadanie z kodemPraca z tablicami
  2. Kliknij w kolejnościSortowanie: Template literal
  3. PytaniePodstawy tablic - metoda pop()
  4. Zadanie z kodemObliczenia z BigInt
  5. Ułóż w kolejnościSkładnia typeof
  6. Zadanie z kodemĆwiczenie: Stwórz zmienną przechowującą gatunek dinozaura
  7. Ułóż w kolejnościRozwiązywanie zakresu zmiennych
  8. Ułóż w kolejnościSkładnia funkcji strzałkowej
  9. PytanieOperator typeof
  10. Zadanie z kodemĆwiczenie: Napisz funkcję obliczającą wiek skamieniałości
  11. Kliknij w kolejnościProces alokacji pamięci
  12. Ułóż w kolejnościPrzepływ sprawdzania typów
  13. Ułóż w kolejnościEwolucja typów w JavaScript
  14. Kliknij w kolejnościPodstawy tablic - składnia deklaracji
  15. Ułóż w kolejnościCykl zarządzania pamięcią
  16. PytanieDebugowanie problemów ze zmiennymi
  17. Ułóż w kolejnościPodstawy tablic - składnia metody push()
  18. PytanieOptymalizacja zmiennych

Przydatne artykuły