Kurs JavaScript i TypeScript · Moduł 2: Funkcje, tablice i obiekty
Podstawowe metody tablic w JavaScript
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}`); // 5Kiedy 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}`); // 5Kiedy 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ęciaitem1, 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:
- push() - dodaje elementy na końcu tablicy
- pop() - usuwa i zwraca ostatni element tablicy
- unshift() - dodaje elementy na początku tablicy
- shift() - usuwa i zwraca pierwszy element tablicy
- splice() - dodaje, usuwa lub zastępuje elementy w dowolnym miejscu tablicy
- sort() - sortuje elementy tablicy
- reverse() - odwraca kolejność elementów w tablicy
- 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. Co robi metoda Array.prototype.pop()?
2. Co zwróci typeof undefined?
3. Który sposób jest najprostszy do sprawdzenia wartości zmiennej podczas debugowania?
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:
Zadania po tej lekcji
- Zadanie z kodemPraca z tablicami
- Kliknij w kolejnościSortowanie: Template literal
- PytaniePodstawy tablic - metoda pop()
- Zadanie z kodemObliczenia z BigInt
- Ułóż w kolejnościSkładnia typeof
- Zadanie z kodemĆwiczenie: Stwórz zmienną przechowującą gatunek dinozaura
- Ułóż w kolejnościRozwiązywanie zakresu zmiennych
- Ułóż w kolejnościSkładnia funkcji strzałkowej
- PytanieOperator typeof
- Zadanie z kodemĆwiczenie: Napisz funkcję obliczającą wiek skamieniałości
- Kliknij w kolejnościProces alokacji pamięci
- Ułóż w kolejnościPrzepływ sprawdzania typów
- Ułóż w kolejnościEwolucja typów w JavaScript
- Kliknij w kolejnościPodstawy tablic - składnia deklaracji
- Ułóż w kolejnościCykl zarządzania pamięcią
- PytanieDebugowanie problemów ze zmiennymi
- Ułóż w kolejnościPodstawy tablic - składnia metody push()
- PytanieOptymalizacja zmiennych