Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript

ES Modules (import/export)

9 min czytania ·
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:

  1. Enkapsulacja - każdy moduł ma własną przestrzeń nazw, co zapobiega konfliktom nazwowym
  2. Reużywalność - możemy łatwo ponownie używać modułów w różnych częściach aplikacji
  3. Organizacja - łatwiej jest zrozumieć i utrzymać kod, gdy jest podzielony na logiczne części
  4. Współpraca w zespole - różni członkowie zespołu mogą pracować nad odrębnymi modułami
  5. Lazy loading - możemy ładować moduły tylko wtedy, gdy są potrzebne
  6. 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

  1. Jedna odpowiedzialność - każdy moduł powinien mieć jedną, jasno określoną odpowiedzialność
  2. Małe moduły - staraj się, aby moduły były małe i skupione na określonym zadaniu
  3. Spójne nazewnictwo - używaj spójnych konwencji nazewnictwa dla plików modułów
  4. Jawne zależności - wszystkie zależności powinny być jasno zdefiniowane w importach
  5. Minimalizacja modyfikacji stanu - unikaj modyfikowania stanu globalnego w modułach
  6. Dokumentacja - dodawaj komentarze JSDoc do eksportowanych funkcji i klas
  7. 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. 1. Czym jest moduł w JavaScript?

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż elementy importu modułu:

  1. PytanieModuły JavaScript
  2. Ułóż w kolejnościSkładnia import

Przydatne artykuły