Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript
ES Modules (import/export)
W tej lekcji11
Witaj z powrotem w Parku Jurajskim! Po zdobyciu solidnych podstaw JavaScript i poznaniu technik asynchronicznych, czas na poznanie sposobów organizacji kodu w większe, skalowalne projekty. W świecie tak złożonym jak Park Jurajski, potrzebujemy dobrze zorganizowanej struktury, aby zapewnić bezpieczeństwo i efektywność systemu.
Modularyzacja kodu w JavaScript
Wyobraź sobie, że zarządzasz Parkiem Jurajskim bez podziału na zespoły i działy - wszystko byłoby chaotyczne i niebezpieczne! Podobnie jest z kodem - gdy wszystko znajduje się w jednym pliku, szybko staje się to nieczytelne i trudne w utrzymaniu.
ES Modules (ECMAScript Modules) to standardowy system modułów w JavaScript, który pozwala na:
- Dzielenie kodu na mniejsze, łatwiejsze w zarządzaniu części
- Kontrolowanie, które elementy są dostępne na zewnątrz modułu
- Definiowanie zależności między różnymi częściami programu
Eksportowanie elementów z modułów
Zacznijmy od stworzenia kilku podstawowych modułów dla naszego systemu zarządzania Parkiem Jurajskim:
1. Eksport domyślny (default export)
Gdy mamy jeden główny element do wyeksportowania, używamy eksportu domyślnego:
// dinosaur.js - Model dinozaura
class Dinosaur {
constructor(name, species, diet, dangerLevel) {
this.name = name;
this.species = species;
this.diet = diet;
this.dangerLevel = dangerLevel;
this.health = 100;
this.isContained = true;
}
feed() {
this.health = Math.min(100, this.health + 20);
return `${this.name} został nakarmiony. Poziom zdrowia: ${this.health}%`;
}
checkStatus() {
return {
name: this.name,
health: this.health,
isContained: this.isContained,
warning: this.dangerLevel > 7 ? "WYSOKI POZIOM ZAGROŻENIA" : ""
};
}
}
// Eksport domyślny - tylko jedna klasa/funkcja/obiekt per plik
export default Dinosaur;2. Eksport nazwany (named exports)
Gdy mamy wiele elementów do wyeksportowania, używamy eksportów nazwanych:
// securityUtils.js - Narzędzia do obsługi bezpieczeństwa
export const SECURITY_LEVELS = {
GREEN: "normalny",
YELLOW: "podwyższony",
ORANGE: "wysoki",
RED: "krytyczny"
};
export function checkFenceStatus(sectorId) {
// Symulacja sprawdzania statusu ogrodzenia w danym sektorze
const status = Math.random() > 0.1 ? "active" : "failure";
return {
sector: sectorId,
status,
timestamp: new Date().toISOString()
};
}
export function triggerAlarm(sector, reason) {
console.log(`ALARM! Sektor ${sector}: ${reason}`);
// Logika uruchamiania alarmu
return {
success: true,
alarmId: "ALR-" + Math.floor(Math.random() * 10000)
};
}
// Możemy też eksportować funkcję domyślną obok nazwanych eksportów
export default function getSecurityStatus() {
// Zwraca ogólny status bezpieczeństwa parku
return {
level: SECURITY_LEVELS.GREEN,
activeAlarms: 0,
lastChecked: new Date().toISOString()
};
}3. Eksportowanie wcześniej zdefiniowanych zmiennych
Możemy też najpierw zdefiniować nasze zmienne, funkcje lub klasy, a następnie wyeksportować je na końcu pliku:
// parkStats.js - Statystyki Parku Jurajskiego
const totalVisitors = 0;
const revenue = 0;
const incidents = [];
function addVisitors(count) {
totalVisitors += count;
return totalVisitors;
}
function addRevenue(amount) {
revenue += amount;
return revenue;
}
function recordIncident(type, location, description) {
const incident = {
id: incidents.length + 1,
type,
location,
description,
timestamp: new Date().toISOString()
};
incidents.push(incident);
return incident;
}
function getDailyStats() {
return {
totalVisitors,
revenue,
incidentCount: incidents.length
};
}
// Eksport wielu elementów naraz
export {
addVisitors,
addRevenue,
recordIncident,
getDailyStats
};
// Możemy również zmienić nazwę eksportowanego elementu
export { recordIncident as logParkIncident };Importowanie elementów z modułów
Po utworzeniu modułów, czas je wykorzystać w głównej aplikacji:
1. Import domyślny
// app.js
import Dinosaur from './dinosaur.js';
// Tworzymy nowe instancje dinozaurów
const trex = new Dinosaur("Rex", "Tyrannosaurus", "carnivore", 9);
const brachi = new Dinosaur("Longneck", "Brachiosaurus", "herbivore", 4);
console.log(trex.checkStatus());
console.log(brachi.feed());2. Import nazwany
// securityMonitor.js
import { checkFenceStatus, triggerAlarm, SECURITY_LEVELS } from './securityUtils.js';
// Używamy importowanych funkcji i stałych
function monitorSecurity() {
const sectors = ["A1", "B2", "C3", "D4"];
// Sprawdzamy każdy sektor
sectors.forEach(sector => {
const fenceStatus = checkFenceStatus(sector);
if (fenceStatus.status === "failure") {
const alarmResult = triggerAlarm(
sector,
"Awaria ogrodzenia elektrycznego!"
);
console.log(`Alarm ${alarmResult.alarmId} uruchomiony w sektorze ${sector}`);
document.querySelector("#securityStatus").textContent = SECURITY_LEVELS.RED;
}
});
}
setInterval(monitorSecurity, 60000); // Sprawdzanie co minutę3. Import domyślny i nazwany razem
// dashboard.js
import getSecurityStatus, { SECURITY_LEVELS, checkFenceStatus } from './securityUtils.js';
// Używamy domyślnego importu
const parkStatus = getSecurityStatus();
console.log("Status bezpieczeństwa:", parkStatus.level);
// Używamy nazwanych importów
if (parkStatus.level === SECURITY_LEVELS.RED) {
// Sprawdź wszystkie sektory natychmiast
["A1", "B2", "C3", "D4"].forEach(sector => {
console.log(`Sprawdzanie sektora ${sector}: `, checkFenceStatus(sector));
});
}4. Import ze zmianą nazwy
// incidentReport.js
import { recordIncident as logIncident } from './parkStats.js';
// Używamy zaimportowanej funkcji pod nową nazwą
function reportEmergency(location, details) {
logIncident("EMERGENCY", location, details);
// Dodatkowa logika obsługi sytuacji awaryjnej
}5. Import wszystkiego jako obiekt
// adminPanel.js
import * as ParkStats from './parkStats.js';
// Dostęp do wszystkich funkcji z modułu przez obiekt
function generateDailyReport() {
const visitorCount = ParkStats.addVisitors(120); // Dodaje 120 odwiedzających
const dailyRevenue = ParkStats.addRevenue(15000); // Dodaje $15,000 przychodu
const stats = ParkStats.getDailyStats();
return `
Dzienny raport Parku Jurajskiego:
- Liczba odwiedzających: ${stats.totalVisitors}
- Przychód: $${stats.revenue}
- Incydenty: ${stats.incidentCount}
`;
}Agregacja i re-eksportowanie modułów
W dużych projektach często warto stworzyć punkty wejścia, które agregują i re-eksportują funkcjonalności z wielu mniejszych modułów:
// models/index.js - Agregacja wszystkich modeli
export { default as Dinosaur } from './dinosaur.js';
export { default as Employee } from './employee.js';
export { default as Facility } from './facility.js';
export { default as Visitor } from './visitor.js';Dzięki temu możemy importować wszystkie modele z jednego punktu wejścia:
// main.js
import { Dinosaur, Employee, Facility } from './models/index.js';
// Teraz możemy korzystać z wszystkich modeli
const rex = new Dinosaur("Rex", "Tyrannosaurus", "carnivore", 9);
const lab = new Facility("Laboratoria InGen", "B3", 12);
const scientist = new Employee("Dr. Wu", "Główny genetyk", "lab");Dynamiczne importowanie modułów
ES Modules oferują również mechanizm dynamicznego importowania, co pozwala na ładowanie modułów na żądanie:
// emergencySystem.js
async function handleEmergency(type) {
let emergencyModule;
switch(type) {
case "dinosaurEscape":
emergencyModule = await import('./emergencies/dinosaurEscape.js');
break;
case "powerOutage":
emergencyModule = await import('./emergencies/powerOutage.js');
break;
case "weatherAlert":
emergencyModule = await import('./emergencies/weatherAlert.js');
break;
default:
emergencyModule = await import('./emergencies/generalEmergency.js');
}
// Wykonaj procedurę awaryjną z załadowanego modułu
emergencyModule.initiateProtocol();
}
// Przycisk w UI do uruchomienia procedury awaryjnej
document.querySelector("#emergencyButton").addEventListener("click", () => {
const emergencyType = document.querySelector("#emergencyType").value;
handleEmergency(emergencyType);
});Specyfika ES Modules w przeglądarce
Aby używać ES Modules bezpośrednio w przeglądarce, musimy dodać atrybut type="module" do tagu script:
<!DOCTYPE html>
<html>
<head>
<title>Panel Kontrolny Parku Jurajskiego</title>
</head>
<body>
<h1>Panel Kontrolny Parku Jurajskiego</h1>
<div id="securityStatus"></div>
<select id="emergencyType">
<option value="dinosaurEscape">Ucieczka dinozaura</option>
<option value="powerOutage">Awaria zasilania</option>
<option value="weatherAlert">Alert pogodowy</option>
</select>
<button id="emergencyButton">Uruchom procedurę awaryjną</button>
<!-- Główny skrypt używający modułów -->
<script type="module" src="./app.js"></script>
</body>
</html>Zalety modularnego podejścia
Organizowanie aplikacji z wykorzystaniem ES Modules oferuje wiele korzyści:
- Enkapsulacja - każdy moduł ma własną przestrzeń nazw, co zapobiega konfliktom nazwowym
- Reużywalność - możemy łatwo ponownie używać modułów w różnych częściach aplikacji
- Organizacja - łatwiej jest zrozumieć i utrzymać kod, gdy jest podzielony na logiczne części
- Współpraca w zespole - różni członkowie zespołu mogą pracować nad odrębnymi modułami
- Lazy loading - możemy ładować moduły tylko wtedy, gdy są potrzebne
- Lepsze zarządzanie zależnościami - jasno zdefiniowane zależności między modułami
Praktyczny przykład: System monitorowania dinozaurów
Zobaczmy, jak moglibyśmy zorganizować większy system monitorowania dinozaurów w Parku Jurajskim z wykorzystaniem modułów:
// models/dinosaur.js
export default class Dinosaur {
// ... implementacja klasy Dinosaur (jak wcześniej)
}
// services/dinoTracking.js
import Dinosaur from '../models/dinosaur.js';
export async function getAllDinosaurs() {
// Pobieranie danych o dinozaurach z API
const response = await fetch('/api/dinosaurs');
const data = await response.json();
// Konwersja surowych danych na instancje klasy Dinosaur
return data.map(dino => new Dinosaur(
dino.name,
dino.species,
dino.diet,
dino.dangerLevel
));
}
export async function getDinosaursByDangerLevel(level) {
const allDinos = await getAllDinosaurs();
return allDinos.filter(dino => dino.dangerLevel >= level);
}
// services/securitySystem.js
export async function getActiveFences() {
// Pobieranie danych o aktywnych ogrodzeniach
const response = await fetch('/api/fences/active');
return response.json();
}
export async function activateSectorLockdown(sectorId) {
// Uruchamianie blokady w danym sektorze
const response = await fetch(`/api/sectors/${sectorId}/lockdown`, {
method: 'POST'
});
return response.json();
}
// utils/alertSystem.js
export const ALERT_LEVELS = {
INFO: 'info',
WARNING: 'warning',
DANGER: 'danger',
CRITICAL: 'critical'
};
export function showAlert(message, level = ALERT_LEVELS.INFO) {
const alertElement = document.createElement('div');
alertElement.className = `alert alert-${level}`;
alertElement.textContent = message;
document.querySelector('#alertContainer').appendChild(alertElement);
// Usunięcie alertu po 5 sekundach (chyba że jest krytyczny)
if (level !== ALERT_LEVELS.CRITICAL) {
setTimeout(() => {
alertElement.remove();
}, 5000);
}
}
// controllers/monitoringDashboard.js
import { getAllDinosaurs, getDinosaursByDangerLevel } from '../services/dinoTracking.js';
import { getActiveFences, activateSectorLockdown } from '../services/securitySystem.js';
import { showAlert, ALERT_LEVELS } from '../utils/alertSystem.js';
export async function initializeDashboard() {
try {
// Pobierz dane o dinozaurach i statusie ogrodzeń
const [allDinos, activeFences] = await Promise.all([
getAllDinosaurs(),
getActiveFences()
]);
// Znajdź niebezpieczne dinozaury
const dangerousDinos = await getDinosaursByDangerLevel(8);
// Wyświetl dane na dashboardzie
renderDinosaurTable(allDinos);
renderSecurityStatus(activeFences);
// Pokaż alerty dla niebezpiecznych dinozaurów
if (dangerousDinos.length > 0) {
showAlert(
`UWAGA: ${dangerousDinos.length} dinozaurów z wysokim poziomem zagrożenia`,
ALERT_LEVELS.WARNING
);
}
// Ustaw nasłuchiwanie na zdarzenia awaryjne
setupEmergencyHandlers();
} catch (error) {
showAlert(`Błąd inicjalizacji dashboardu: ${error.message}`, ALERT_LEVELS.DANGER);
}
}
function renderDinosaurTable(dinosaurs) {
// Logika renderowania tabeli dinozaurów
}
function renderSecurityStatus(fences) {
// Logika renderowania statusu zabezpieczeń
}
function setupEmergencyHandlers() {
// Logika ustawiania obsługi zdarzeń awaryjnych
document.querySelector('#emergencyLockdown').addEventListener('click', async () => {
const sector = document.querySelector('#sectorSelect').value;
try {
await activateSectorLockdown(sector);
showAlert(`Blokada sektora ${sector} aktywowana`, ALERT_LEVELS.WARNING);
} catch (error) {
showAlert(`Nie udało się aktywować blokady: ${error.message}`, ALERT_LEVELS.CRITICAL);
}
});
}
// app.js - Główny plik aplikacji
import { initializeDashboard } from './controllers/monitoringDashboard.js';
// Inicjalizacja aplikacji gdy DOM jest gotowy
document.addEventListener('DOMContentLoaded', () => {
initializeDashboard();
// Dodatkowa logika inicjalizacyjna
console.log('System monitorowania Parku Jurajskiego uruchomiony');
});Wsparcie przeglądarek i konfiguracja Webpack
Nowsze przeglądarki obsługują ES Modules natywnie, ale dla pełnej kompatybilności z starszymi przeglądarkami często używamy narzędzi takich jak Webpack lub Rollup, które bundlują nasze moduły w kod kompatybilny z starszymi przeglądarkami.
Podstawowa konfiguracja Webpack dla ES Modules
// webpack.config.js
const path = require('path');
module.exports = {
entry: './src/app.js',
output: {
filename: 'bundle.js',
path: path.resolve(__dirname, 'dist')
},
module: {
rules: [
{
test: /\.js$/,
exclude: /node_modules/,
use: {
loader: 'babel-loader',
options: {
presets: ['@babel/preset-env']
}
}
}
]
}
};Dobre praktyki przy pracy z modułami
- Jedna odpowiedzialność - każdy moduł powinien mieć jedną, jasno określoną odpowiedzialność
- Małe moduły - staraj się, aby moduły były małe i skupione na określonym zadaniu
- Spójne nazewnictwo - używaj spójnych konwencji nazewnictwa dla plików modułów
- Jawne zależności - wszystkie zależności powinny być jasno zdefiniowane w importach
- Minimalizacja modyfikacji stanu - unikaj modyfikowania stanu globalnego w modułach
- Dokumentacja - dodawaj komentarze JSDoc do eksportowanych funkcji i klas
- Struktura folderów - organizuj moduły w logiczną strukturę folderów (np. models, services, utils)
Podsumowanie
ES Modules to potężny mechanizm organizacji kodu w JavaScript, który pozwala na tworzenie modularnych, dobrze zorganizowanych aplikacji. W świecie tak złożonym jak Park Jurajski, gdzie każdy błąd może mieć katastrofalne konsekwencje, dobra organizacja kodu jest kluczowa dla utrzymania bezpieczeństwa i wydajności.
W następnym ćwiczeniu przyjrzymy się alternatywnemu systemowi modułów - CommonJS, który jest szeroko używany w środowisku Node.js, idealnym do tworzenia serwerowej części naszego systemu zarządzania Parkiem Jurajskim.
Kod do tej lekcji: main.js
// ES Modules w Parku Jurajskim
// Główny plik systemu zarządzania parkiem
console.log("System Zarządzania Parkiem Jurajskim");
console.log("Demonstracja ES Modules (import/export)\n");
// ===========================================
// Symulacja importów (w prawdziwym ES6 byłyby to oddzielne pliki)
// ===========================================
// === dinosaur.js - Model dinozaura ===
class Dinosaur {
constructor(name, species, diet, dangerLevel) {
this.name = name;
this.species = species;
this.diet = diet;
this.dangerLevel = dangerLevel; // 1-10
this.isActive = true;
this.lastFed = new Date();
this.energy = 100;
}
feed() {
this.energy = Math.min(100, this.energy + 20);
this.lastFed = new Date();
return `${this.name} został nakarmiony. Energia: ${this.energy}%`;
}
roar() {
const sounds = {
'carnivore': 'ROAAAAR!',
'herbivore': 'Hoooonk!',
'omnivore': 'Grrrrooo!'
};
return `${this.name}: ${sounds[this.diet] || 'Hmm?'}`;
}
getInfo() {
return {
name: this.name,
species: this.species,
diet: this.diet,
dangerLevel: this.dangerLevel,
energy: this.energy,
status: this.isActive ? 'Active' : 'Sleeping'
};
}
}
// Eksport domyślny (default export)
const DinosaurClass = Dinosaur;
// === security.js - System bezpieczeństwa ===
const SECURITY_LEVELS = {
GREEN: 1,
YELLOW: 2,
ORANGE: 3,
RED: 4,
CRITICAL: 5
};
function calculateSecurityLevel(dinosaurs) {
const maxDanger = Math.max(...dinosaurs.map(d => d.dangerLevel));
const activeCarnivores = dinosaurs.filter(d => d.diet === 'carnivore' && d.isActive).length;
if (maxDanger >= 9 || activeCarnivores >= 3) return SECURITY_LEVELS.CRITICAL;
if (maxDanger >= 7 || activeCarnivores >= 2) return SECURITY_LEVELS.RED;
if (maxDanger >= 5 || activeCarnivores >= 1) return SECURITY_LEVELS.ORANGE;
if (maxDanger >= 3) return SECURITY_LEVELS.YELLOW;
return SECURITY_LEVELS.GREEN;
}
function getSecurityMessage(level) {
const messages = {
[SECURITY_LEVELS.GREEN]: "Park bezpieczny",
[SECURITY_LEVELS.YELLOW]: "Podwyższona czujność",
[SECURITY_LEVELS.ORANGE]: "Zagrożenie średnie",
[SECURITY_LEVELS.RED]: "Wysokie zagrożenie",
[SECURITY_LEVELS.CRITICAL]: "STAN KRYTYCZNY"
};
return messages[level] || "Nieznany poziom";
}
// Eksport nazwane (named exports)
const SecurityModule = {
SECURITY_LEVELS,
calculateSecurityLevel,
getSecurityMessage
};
// === enclosure.js - Zarządzanie wybiegami ===
class Enclosure {
constructor(id, name, capacity, type) {
this.id = id;
this.name = name;
this.capacity = capacity;
this.type = type; // 'carnivore', 'herbivore', 'mixed'
this.dinosaurs = [];
this.isLocked = true;
this.maintenanceMode = false;
}
addDinosaur(dinosaur) {
if (this.dinosaurs.length >= this.capacity) {
return `Błąd: Wybieg ${this.name} jest pełny`;
}
if (this.type === 'carnivore' && dinosaur.diet !== 'carnivore') {
return `Błąd: Wybieg dla mięsożerców nie może przyjąć ${dinosaur.diet}`;
}
if (this.type === 'herbivore' && dinosaur.diet === 'carnivore') {
return `Błąd: Wybieg dla roślinożerców nie może przyjąć mięsożerców`;
}
this.dinosaurs.push(dinosaur);
return `${dinosaur.name} dodany do wybiegu ${this.name}`;
}
removeDinosaur(dinosaurName) {
const index = this.dinosaurs.findIndex(d => d.name === dinosaurName);
if (index === -1) {
return `Błąd: Dinozaur ${dinosaurName} nie znajduje się w tym wybiegu`;
}
const removed = this.dinosaurs.splice(index, 1)[0];
return `${removed.name} usunięty z wybiegu ${this.name}`;
}
feedAll() {
const results = this.dinosaurs.map(dinosaur => dinosaur.feed());
return results;
}
getStatus() {
return {
id: this.id,
name: this.name,
capacity: this.capacity,
occupied: this.dinosaurs.length,
type: this.type,
isLocked: this.isLocked,
maintenanceMode: this.maintenanceMode,
dinosaurs: this.dinosaurs.map(d => d.getInfo())
};
}
lock() {
this.isLocked = true;
return `Wybieg ${this.name} zamknięty`;
}
unlock() {
this.isLocked = false;
return `Wybieg ${this.name} otwarty`;
}
}
const EnclosureClass = Enclosure;
// === utils.js - Funkcje pomocnicze ===
function formatTime(date) {
return date.toLocaleTimeString('pl-PL');
}
function generateId() {
return 'ID-' + Math.random().toString(36).substr(2, 9).toUpperCase();
}
function logAction(action, details = '') {
const timestamp = formatTime(new Date());
const logEntry = `[${timestamp}] ${action} ${details}`;
console.log(logEntry);
return logEntry;
}
function calculateDistance(point1, point2) {
const dx = point2.x - point1.x;
const dy = point2.y - point1.y;
return Math.sqrt(dx * dx + dy * dy);
}
// Eksport wielu funkcji
const UtilsModule = {
formatTime,
generateId,
logAction,
calculateDistance
};
// === park-manager.js - Główny system zarządzania ===
class ParkManager {
constructor() {
this.enclosures = new Map();
this.dinosaurs = new Map();
this.securityLevel = SecurityModule.SECURITY_LEVELS.GREEN;
this.isOpen = false;
this.visitors = 0;
}
// Zarządzanie wybiegami
createEnclosure(name, capacity, type) {
const id = UtilsModule.generateId();
const enclosure = new EnclosureClass(id, name, capacity, type);
this.enclosures.set(id, enclosure);
UtilsModule.logAction('ENCLOSURE_CREATED', `${name} (capacity: ${capacity}, type: ${type})`);
return enclosure;
}
// Zarządzanie dinozaurami
addDinosaur(name, species, diet, dangerLevel, enclosureId) {
const dinosaur = new DinosaurClass(name, species, diet, dangerLevel);
this.dinosaurs.set(name, dinosaur);
if (enclosureId && this.enclosures.has(enclosureId)) {
const enclosure = this.enclosures.get(enclosureId);
const result = enclosure.addDinosaur(dinosaur);
UtilsModule.logAction('DINOSAUR_ADDED', `${name} -> ${enclosure.name}`);
console.log(result);
}
this.updateSecurityLevel();
return dinosaur;
}
// Aktualizacja poziomu bezpieczeństwa
updateSecurityLevel() {
const allDinosaurs = Array.from(this.dinosaurs.values());
this.securityLevel = SecurityModule.calculateSecurityLevel(allDinosaurs);
const message = SecurityModule.getSecurityMessage(this.securityLevel);
UtilsModule.logAction('SECURITY_UPDATE', message);
}
// Raport stanu parku
getParkStatus() {
const enclosureStatuses = Array.from(this.enclosures.values()).map(e => e.getStatus());
const dinosaurCount = this.dinosaurs.size;
const securityMessage = SecurityModule.getSecurityMessage(this.securityLevel);
return {
isOpen: this.isOpen,
visitors: this.visitors,
dinosaurCount,
enclosureCount: this.enclosures.size,
securityLevel: this.securityLevel,
securityMessage,
enclosures: enclosureStatuses,
timestamp: UtilsModule.formatTime(new Date())
};
}
// Otwarcie/zamknięcie parku
openPark() {
if (this.securityLevel <= SecurityModule.SECURITY_LEVELS.YELLOW) {
this.isOpen = true;
UtilsModule.logAction('PARK_OPENED', 'Park otwarty dla zwiedzających');
return "Park Jurajski otwarty!";
} else {
return "Park nie może być otwarty - zbyt wysokie zagrożenie";
}
}
closePark() {
this.isOpen = false;
this.visitors = 0;
UtilsModule.logAction('PARK_CLOSED', 'Park zamknięty');
return "Park Jurajski zamknięty";
}
// Karmienie wszystkich dinozaurów
feedAllDinosaurs() {
const results = [];
for (const enclosure of this.enclosures.values()) {
const feedResults = enclosure.feedAll();
results.push(...feedResults);
}
UtilsModule.logAction('MASS_FEEDING', `Nakarmiono ${results.length} dinozaurów`);
return results;
}
// Sytuacja awaryjna
emergencyProtocol() {
UtilsModule.logAction('EMERGENCY', 'Aktywowano protokół awaryjny!');
// Zamknij park
this.closePark();
// Zamknij wszystkie wybiegi
for (const enclosure of this.enclosures.values()) {
enclosure.lock();
}
console.log("PROTOKÓŁ AWARYJNY AKTYWOWANY!");
console.log("- Park zamknięty");
console.log("- Wszystkie wybiegi zablokowane");
console.log("- Ewakuacja gości w toku");
return "Protokół awaryjny aktywowany";
}
}
// ===========================================
// DEMONSTRACJA SYSTEMU
// ===========================================
console.log("=== INICJALIZACJA SYSTEMU PARKU ===\n");
// Tworzenie managera parku
const parkManager = new ParkManager();
// Tworzenie wybiegów
console.log("Tworzenie wybiegów...");
const carnivorePaddock = parkManager.createEnclosure("Paddock A - Mięsożercy", 3, "carnivore");
const herbivorePaddock = parkManager.createEnclosure("Paddock B - Roślinożercy", 5, "herbivore");
const mixedPaddock = parkManager.createEnclosure("Paddock C - Mieszany", 4, "mixed");
console.log("\nDodawanie dinozaurów...");
// Dodawanie dinozaurów
const trex = parkManager.addDinosaur(
"Rexy",
"Tyrannosaurus Rex",
"carnivore",
9,
carnivorePaddock.id
);
const raptor1 = parkManager.addDinosaur(
"Blue",
"Velociraptor",
"carnivore",
7,
carnivorePaddock.id
);
const raptor2 = parkManager.addDinosaur(
"Charlie",
"Velociraptor",
"carnivore",
7,
carnivorePaddock.id
);
const trice = parkManager.addDinosaur(
"Spike",
"Triceratops",
"herbivore",
3,
herbivorePaddock.id
);
const brachi = parkManager.addDinosaur(
"Gentle Giant",
"Brachiosaurus",
"herbivore",
2,
herbivorePaddock.id
);
const stego = parkManager.addDinosaur(
"Spike Jr",
"Stegosaurus",
"herbivore",
4,
mixedPaddock.id
);
// Test dźwięków dinozaurów
console.log("\nTest komunikacji z dinozaurami:");
console.log(trex.roar());
console.log(raptor1.roar());
console.log(trice.roar());
console.log(brachi.roar());
// Raport stanu parku
console.log("\nRAPORT STANU PARKU:");
const status = parkManager.getParkStatus();
console.log(`Status: ${status.isOpen ? 'Otwarty' : 'Zamknięty'}`);
console.log(`Dinozaury: ${status.dinosaurCount}`);
console.log(`Wybiegi: ${status.enclosureCount}`);
console.log(`Bezpieczeństwo: ${status.securityMessage}`);
// Próba otwarcia parku
console.log("\nPróba otwarcia parku...");
const openResult = parkManager.openPark();
console.log(openResult);
// Karmienie dinozaurów
console.log("\nKarmienie dinozaurów...");
const feedingResults = parkManager.feedAllDinosaurs();
feedingResults.forEach(result => console.log(" " + result));
// Symulacja sytuacji awaryjnej
console.log("\nSymulacja awarii...");
setTimeout(() => {
console.log("\nWYKRYTO NIEBEZPIECZEŃSTWO!");
parkManager.emergencyProtocol();
// Status po awarii
setTimeout(() => {
console.log("\nStatus po protokole awaryjnym:");
const finalStatus = parkManager.getParkStatus();
console.log(`Park: ${finalStatus.isOpen ? 'Otwarty' : 'Zamknięty'}`);
console.log(`Bezpieczeństwo: ${finalStatus.securityMessage}`);
console.log("\nSzczegóły wybiegów:");
finalStatus.enclosures.forEach(enc => {
console.log(` ${enc.name}: ${enc.occupied}/${enc.capacity} dinozaurów, ${enc.isLocked ? 'Zamknięty' : 'Otwarty'}`);
});
}, 2000);
}, 3000);
// ===========================================
// DEMONSTRACJA RÓŻNYCH TYPÓW EKSPORTÓW
// ===========================================
console.log("\n=== TYPY EKSPORTÓW ES6 ===");
// 1. Default export - jedna główna rzecz z modułu
console.log("1. Default export - główna klasa Dinosaur");
const myDino = new DinosaurClass("Test Dino", "Test Species", "omnivore", 5);
console.log(" Utworzono:", myDino.name);
// 2. Named exports - wiele funkcji/obiektów
console.log("\n2. Named exports - funkcje użytkowe");
console.log(" Generated ID:", UtilsModule.generateId());
console.log(" Current time:", UtilsModule.formatTime(new Date()));
// 3. Re-exports - eksportowanie z innych modułów
console.log("\n3. Security module exports");
console.log(" Security levels:", Object.keys(SecurityModule.SECURITY_LEVELS));
// 4. Namespace import - wszystko jako jeden obiekt
console.log("\n4. Combined module usage:");
const testEnclosure = new EnclosureClass("TEST-001", "Test Enclosure", 2, "mixed");
testEnclosure.addDinosaur(myDino);
console.log(" Test enclosure created with:", testEnclosure.dinosaurs.length, "dinosaur(s)");
// ===========================================
// SYMULACJA RZECZYWISTYCH IMPORTÓW ES6
// ===========================================
console.log("\n=== SYMULACJA IMPORTÓW ES6 ===");
console.log("W prawdziwej aplikacji używalibyśmy:");
console.log("");
console.log("// main.js");
console.log("import Dinosaur from './dinosaur.js'; // default import");
console.log("import { SECURITY_LEVELS, calculateSecurityLevel } from './security.js'; // named imports");
console.log("import * as Utils from './utils.js'; // namespace import");
console.log("import Enclosure, { EnclosureType } from './enclosure.js'; // mixed import");
console.log("");
console.log("// dinosaur.js");
console.log("export default class Dinosaur { ... }");
console.log("");
console.log("// security.js");
console.log("export const SECURITY_LEVELS = { ... };");
console.log("export function calculateSecurityLevel(dinosaurs) { ... }");
console.log("");
console.log("// utils.js");
console.log("export function formatTime(date) { ... }");
console.log("export function generateId() { ... }");
console.log("export { formatTime as timeFormatter }; // alias export");
console.log("\nDemonstracja ES Modules zakończona!");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. Czym jest moduł w JavaScript?
Zadania praktyczne w grze
- Układanie w poziomie
Ułóż elementy importu modułu: