Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript

Dynamiczne importowanie modułów

14 min czytania ·
W tej lekcji7

W poprzednich ćwiczeniach poznaliśmy dwa główne systemy modułów w JavaScript: ES Modules oraz CommonJS. Oba systemy umożliwiają organizację kodu w niezależne moduły, ale zapoznaliśmy się głównie ze statycznymi importami. Teraz przejdziemy do następnego poziomu - dynamicznego importowania modułów, które daje nam znacznie większą elastyczność.

Dla naszego systemu zarządzania Parkiem Jurajskim, dynamiczne importy mogą być kluczowe. Wyobraź sobie, że potrzebujemy różnych procedur awaryjnych w zależności od tego, co się dzieje - ucieczka T-Rexa wymaga innego zestawu akcji niż awaria zasilania czy zbliżający się huragan!

Wprowadzenie do dynamicznego importowania

Dynamiczne importowanie modułów pozwala na ładowanie modułów w trakcie działania programu, a nie podczas jego inicjalizacji. Oznacza to, że możemy wczytać moduł dokładnie wtedy, gdy jest potrzebny, oszczędzając pamięć i czas ładowania dla modułów, które mogą nigdy nie zostać użyte.

Syntaktyka dynamicznego importu

Dynamiczny import używa funkcji import(), która zwraca Promise zawierające załadowany moduł:

// Statyczny import (zawsze ładowany)
import { DinosaurTracker } from './dinosaurTracker.js';

// Dynamiczny import (ładowany na żądanie)
import('./emergencyProcedures.js')
  .then(module => {
    // Teraz możemy użyć załadowanego modułu
    module.initializeEmergencyProtocol();
  })
  .catch(error => {
    console.error('Nie udało się załadować procedur awaryjnych:', error);
  });

Jeszcze wygodniej jest używać dynamicznego importu z async/await:

async function handleEmergency(type) {
  try {
    // Dynamicznie importujemy odpowiedni moduł procedury awaryjnej
    const emergencyModule = await import(`./emergencies/${type}.js`);

    // Używamy załadowanego modułu
    return emergencyModule.executeProtocol();
  } catch (error) {
    console.error(`Nie udało się załadować procedury: ${type}`, error);
    // Fallback do ogólnej procedury awaryjnej
    const fallbackModule = await import('./emergencies/general.js');
    return fallbackModule.executeProtocol();
  }
}

// Użycie naszej funkcji
handleEmergency('dinosaurEscape').then(result => {
  console.log('Status procedury awaryjnej:', result);
});

Zastosowania dynamicznego importowania w Parku Jurajskim

Zastanówmy się nad praktycznymi zastosowaniami dynamicznego importowania w naszym systemie zarządzania Parkiem Jurajskim:

1. Ładowanie na żądanie

Możemy ładować funkcjonalności tylko wtedy, gdy są potrzebne, co jest szczególnie przydatne dla rzadko używanych, ale dużych modułów:

// dashboardController.js
async function loadDashboard(dashboardType) {
  // Bazowy dashboard zawsze załadowany
  const statusPanel = document.getElementById('statusPanel');
  statusPanel.innerHTML = 'Ładowanie...';

  try {
    // Dynamicznie importujemy żądany typ dashboardu
    const dashboardModule = await import(`./dashboards/${dashboardType}Dashboard.js`);

    // Inicjalizujemy dashboard
    const dashboard = new dashboardModule.default();
    await dashboard.initialize(statusPanel);

    console.log(`Dashboard ${dashboardType} załadowany pomyślnie`);
  } catch (error) {
    console.error(`Błąd ładowania dashboardu ${dashboardType}: `, error);
    statusPanel.innerHTML = `Błąd ładowania dashboardu: ${error.message}`;
  }
}

// Przyciski w interfejsie użytkownika
document.getElementById('btnDinosaurs').addEventListener('click', () => {
  loadDashboard('dinosaurs');
});

document.getElementById('btnSecurity').addEventListener('click', () => {
  loadDashboard('security');
});

document.getElementById('btnVisitors').addEventListener('click', () => {
  loadDashboard('visitors');
});

2. Różne implementacje dla różnych środowisk

Możemy dynamicznie ładować różne implementacje w zależności od środowiska (produkcja, rozwój, testowe):

async function initializeTracking() {
  const environment = process.env.NODE_ENV || 'development';

  try {
    // Ładujemy odpowiednią implementację dla danego środowiska
    const trackingModule = await import(`./tracking/${environment}.js`);

    // Inicjalizujemy system śledzenia
    const tracker = trackingModule.createTracker();
    tracker.initialize();

    return tracker;
  } catch (error) {
    console.error(`Nie udało się zainicjalizować śledzenia dla środowiska ${environment}: `, error);
    // Fallback do wersji dla developmentu
    const fallbackModule = await import('./tracking/development.js');
    return fallbackModule.createTracker();
  }
}

// Użycie funkcji
initializeTracking().then(tracker => {
  tracker.trackEvent('app_initialized', { timestamp: Date.now() });
});

3. Opóźnione ładowanie komponentów interfejsu (lazy loading)

W aplikacji frontendowej możemy opóźnić ładowanie komponentów interfejsu, aby przyspieszyć początkowe ładowanie strony:

// dynamicComponents.js
export async function loadComponent(componentName) {
  try {
    const module = await import(`./components/${componentName}.js`);
    return module.default;
  } catch (error) {
    console.error(`Nie udało się załadować komponentu ${componentName}: `, error);
    throw error;
  }
}

// W głównym pliku aplikacji
import { loadComponent } from './dynamicComponents.js';

document.getElementById('btnShowMap').addEventListener('click', async () => {
  try {
    // Ładujemy mapę parku tylko, gdy użytkownik jej potrzebuje
    const ParkMap = await loadComponent('ParkMap');
    const mapContainer = document.getElementById('mapContainer');

    const parkMap = new ParkMap({
      container: mapContainer,
      initialZoom: 2,
      centerCoordinates: [34.5, 12.8]
    });

    parkMap.render();
  } catch (error) {
    alert(`Nie udało się załadować mapy: ${error.message}`);
  }
});

4. Dynamiczne ładowanie procedur i protokołów bezpieczeństwa

Jednym z najważniejszych zastosowań w naszym parku będzie system procedur bezpieczeństwa:

// securitySystem.js
export class SecuritySystem {
  constructor() {
    this.activeProtocols = new Map();
    this.alertLevel = 'green';
  }

  async activateProtocol(protocolName, params = {}) {
    try {
      // Sprawdzamy, czy protokół jest już aktywny
      if (this.activeProtocols.has(protocolName)) {
        console.log(`Protokół ${protocolName} jest już aktywny`);
        return this.activeProtocols.get(protocolName);
      }

      // Dynamicznie importujemy protokół
      const protocolModule = await import(`./protocols/${protocolName}.js`);

      // Inicjalizujemy protokół
      const protocol = new protocolModule.default(params);
      await protocol.initialize();

      // Dodajemy do aktywnych protokołów
      this.activeProtocols.set(protocolName, protocol);

      console.log(`Protokół ${protocolName} aktywowany pomyślnie`);
      return protocol;
    } catch (error) {
      console.error(`Błąd aktywacji protokołu ${protocolName}: `, error);
      throw new Error(`Nie udało się aktywować protokołu ${protocolName}: ${error.message}`);
    }
  }

  async deactivateProtocol(protocolName) {
    const protocol = this.activeProtocols.get(protocolName);
    if (!protocol) {
      console.log(`Protokół ${protocolName} nie jest aktywny`);
      return false;
    }

    try {
      await protocol.shutdown();
      this.activeProtocols.delete(protocolName);
      console.log(`Protokół ${protocolName} dezaktywowany pomyślnie`);
      return true;
    } catch (error) {
      console.error(`Błąd dezaktywacji protokołu ${protocolName}: `, error);
      return false;
    }
  }

  async handleEmergency(type, location) {
    console.log(`Obsługa sytuacji awaryjnej: ${type} w lokalizacji ${location}`);

    // Aktualizujemy poziom alertu
    this.alertLevel = 'red';

    try {
      // Importujemy odpowiednią procedurę awaryjną
      const emergencyModule = await import(`./emergencies/${type}.js`);

      // Uruchamiamy procedurę
      const procedure = new emergencyModule.EmergencyProcedure(location);
      const emergencyId = await procedure.execute();

      console.log(`Procedura awaryjna dla ${type} uruchomiona, ID: ${emergencyId}`);
      return emergencyId;
    } catch (error) {
      console.error(`Nie udało się obsłużyć sytuacji awaryjnej ${type}: `, error);

      // Fallback do ogólnej procedury awaryjnej
      try {
        const generalModule = await import('./emergencies/general.js');
        const procedure = new generalModule.EmergencyProcedure(location, { originalType: type });
        return procedure.execute();
      } catch (fallbackError) {
        console.error(`Krytyczny błąd! Nawet ogólna procedura nie działa: `, fallbackError);
        return null;
      }
    }
  }
}

// Użycie systemu bezpieczeństwa
const security = new SecuritySystem();

// Przykłady aktywacji protokołów
document.getElementById('btnLockdown').addEventListener('click', async () => {
  try {
    const protocol = await security.activateProtocol('lockdown', {
      sectors: ['A1', 'B2'],
      reason: 'Ucieczka dinozaura'
    });

    document.getElementById('status').textContent = `Protokół blokady aktywny w ${protocol.affectedSectors.length} sektorach`;
  } catch (error) {
    alert(`Błąd aktywacji protokołu: ${error.message}`);
  }
});

// Przykład obsługi sytuacji awaryjnej
async function reportEmergency(type, location) {
  try {
    const emergencyId = await security.handleEmergency(type, location);
    return emergencyId;
  } catch (error) {
    console.error(`Nie udało się zgłosić sytuacji awaryjnej: `, error);
    return null;
  }
}

Implementacja przykładowych modułów

Zobaczmy, jak mogą wyglądać niektóre z modułów, które dynamicznie importujemy w naszym systemie:

Przykładowy protokół bezpieczeństwa (lockdown.js)

// protocols/lockdown.js
export default class LockdownProtocol {
  constructor(params) {
    this.sectors = params.sectors || [];
    this.reason = params.reason || 'Nieznany powód';
    this.timestamp = new Date();
    this.active = false;
    this.affectedSectors = [];
  }

  async initialize() {
    console.log(`Inicjalizacja protokołu blokady dla sektorów: ${this.sectors.join(', ')}`);

    // Symulacja aktywacji blokady dla każdego sektora
    this.affectedSectors = await Promise.all(
      this.sectors.map(async (sector) => {
        try {
          // W rzeczywistym systemie, tu byłoby API call
          await this.activateSectorLockdown(sector);
          return {
            sector,
            status: 'secured',
            securedAt: new Date()
          };
        } catch (error) {
          console.error(`Błąd blokady sektora ${sector}: `, error);
          return {
            sector,
            status: 'failed',
            error: error.message
          };
        }
      })
    );

    this.active = true;

    // Zwracamy status
    return {
      active: this.active,
      affectedSectors: this.affectedSectors,
      initializedAt: new Date()
    };
  }

  async shutdown() {
    if (!this.active) {
      return { success: false, reason: 'Protocol not active' };
    }

    console.log(`Wyłączanie protokołu blokady dla sektorów: ${this.sectors.join(', ')}`);

    // Symulacja deaktywacji blokady dla każdego sektora
    await Promise.all(
      this.sectors.map(async (sector) => {
        try {
          // W rzeczywistym systemie, tu byłoby API call
          await this.deactivateSectorLockdown(sector);
        } catch (error) {
          console.error(`Błąd odblokowania sektora ${sector}: `, error);
        }
      })
    );

    this.active = false;

    return {
      success: true,
      deactivatedAt: new Date()
    };
  }

  // Metoda symulująca aktywację blokady sektora
  async activateSectorLockdown(sector) {
    return new Promise((resolve, reject) => {
      // Symulacja opóźnienia sieciowego i odpowiedzi API
      setTimeout(() => {
        if (Math.random() > 0.1) {
          resolve({
            sector,
            status: 'secured',
            gates: { closed: 4, total: 4 },
            fences: { energized: true }
          });
        } else {
          reject(new Error(`Błąd blokady sektora ${sector}: Awaria systemu`));
        }
      }, 500 + Math.random() * 1000);
    });
  }

  // Metoda symulująca deaktywację blokady sektora
  async deactivateSectorLockdown(sector) {
    return new Promise((resolve, reject) => {
      // Symulacja opóźnienia sieciowego i odpowiedzi API
      setTimeout(() => {
        if (Math.random() > 0.05) {
          resolve({
            sector,
            status: 'unlocked',
            gates: { closed: 0, total: 4 },
            fences: { energized: true } // Ogrodzenia pozostają pod napięciem
          });
        } else {
          reject(new Error(`Błąd odblokowania sektora ${sector}: Awaria systemu`));
        }
      }, 300 + Math.random() * 700);
    });
  }
}

Przykładowa procedura awaryjna (dinosaurEscape.js)

// emergencies/dinosaurEscape.js
export class EmergencyProcedure {
  constructor(location, options = {}) {
    this.location = location;
    this.options = options;
    this.id = 'EM-' + Date.now().toString(36).toUpperCase();
    this.status = 'initialized';
    this.startTime = new Date();
  }

  async execute() {
    console.log(`Wykonywanie procedury awaryjnej dla ucieczki dinozaura w lokalizacji ${this.location}`);
    this.status = 'in_progress';

    try {
      // 1. Aktywacja alarmu w strefie
      await this.activateZoneAlarm(this.location);

      // 2. Ewakuacja zwiedzających z zagrożonego obszaru
      await this.evacuateVisitors(this.location);

      // 3. Wysłanie zespołu bezpieczeństwa
      const securityTeam = await this.dispatchSecurityTeam(this.location);

      // 4. Aktywacja protokołu blokady w tym i sąsiednich sektorach
      const adjacentSectors = await this.getAdjacentSectors(this.location);
      const allSectors = [this.location, ...adjacentSectors];
      await this.activateLockdown(allSectors);

      // 5. Powiadomienie personelu
      await this.notifyStaff({
        type: 'dinosaur_escape',
        location: this.location,
        securityTeam,
        sectors: allSectors
      });

      this.status = 'completed';
      console.log(`Procedura awaryjna ${this.id} zakończona pomyślnie`);

      return this.id;
    } catch (error) {
      this.status = 'failed';
      console.error(`Procedura awaryjna ${this.id} nie powiodła się: `, error);
      throw error;
    }
  }

  // Metody pomocnicze...
  async activateZoneAlarm(zone) {
    console.log(`Aktywacja alarmu w strefie ${zone}`);
    // Implementacja...
    return { success: true, zone };
  }

  async evacuateVisitors(zone) {
    console.log(`Ewakuacja zwiedzających ze strefy ${zone}`);
    // Implementacja...
    return { success: true, evacuatedCount: Math.floor(Math.random() * 50) + 10 };
  }

  async dispatchSecurityTeam(zone) {
    console.log(`Wysyłanie zespołu bezpieczeństwa do strefy ${zone}`);
    // Implementacja...
    return {
      teamId: 'ST-' + Math.floor(Math.random() * 10) + 1,
      members: Math.floor(Math.random() * 5) + 3,
      estimatedArrival: new Date(Date.now() + 5 * 60 * 1000)
    };
  }

  async getAdjacentSectors(sector) {
    // W rzeczywistym systemie, pobieralibyśmy to z bazy danych
    const sectorMap = {
      'A1': ['A2', 'B1'],
      'A2': ['A1', 'A3', 'B2'],
      'B1': ['A1', 'B2', 'C1'],
      // ... więcej mapowań
    };

    return sectorMap[sector] || [];
  }

  async activateLockdown(sectors) {
    console.log(`Aktywacja blokady w sektorach: ${sectors.join(', ')}`);

    // Dynamicznie importujemy moduł protokołu blokady
    const LockdownModule = await import('../protocols/lockdown.js');
    const lockdown = new LockdownModule.default({
      sectors,
      reason: 'Ucieczka dinozaura'
    });

    return lockdown.initialize();
  }

  async notifyStaff(data) {
    console.log(`Powiadamianie personelu o sytuacji awaryjnej: `, data);
    // Implementacja...
    return { success: true, notifiedCount: Math.floor(Math.random() * 30) + 5 };
  }
}

Budowanie dynamicznego systemu z importami zdeterminowanymi w czasie wykonania

Możemy też tworzyć bardziej zaawansowane systemy, w których ścieżki importów są determinowane w czasie wykonania:

// dynamicModuleLoader.js
export class ModuleLoader {
  constructor(basePath = '') {
    this.basePath = basePath;
    this.cache = new Map();
  }

  async load(modulePath, ignoreCache = false) {
    const fullPath = this.basePath ? `${this.basePath}/${modulePath}` : modulePath;

    // Sprawdź cache, jeśli ignorowanie cache nie jest włączone
    if (!ignoreCache && this.cache.has(fullPath)) {
      console.log(`Zwracanie modułu ${fullPath} z cache`);
      return this.cache.get(fullPath);
    }

    try {
      console.log(`Dynamiczne ładowanie modułu: ${fullPath}`);
      const module = await import(fullPath);

      // Zapisz w cache
      this.cache.set(fullPath, module);

      return module;
    } catch (error) {
      console.error(`Błąd ładowania modułu ${fullPath}: `, error);
      throw error;
    }
  }

  async loadMultiple(modulePaths) {
    try {
      const modulePromises = modulePaths.map(path => this.load(path));
      return await Promise.all(modulePromises);
    } catch (error) {
      console.error(`Błąd ładowania wielu modułów: `, error);
      throw error;
    }
  }

  clearCache(modulePath) {
    if (modulePath) {
      const fullPath = this.basePath ? `${this.basePath}/${modulePath}` : modulePath;
      return this.cache.delete(fullPath);
    } else {
      // Wyczyść cały cache
      this.cache.clear();
      return true;
    }
  }
}

// DinosaurTrackingSystem.js
import { ModuleLoader } from './dynamicModuleLoader.js';

export class DinosaurTrackingSystem {
  constructor() {
    this.moduleLoader = new ModuleLoader('./dinosaurs');
    this.trackers = new Map();
    this.activeDinosaurs = new Set();
  }

  async initialize() {
    // Ładujemy podstawowe moduły
    const [baseUtils, trackingCore] = await this.moduleLoader.loadMultiple([
      './utils.js',
      './trackingCore.js'
    ]);

    this.utils = baseUtils;
    this.trackingCore = trackingCore;

    console.log(`System śledzenia dinozaurów zainicjalizowany.`);
  }

  async trackDinosaur(dinosaurId, species) {
    if (this.trackers.has(dinosaurId)) {
      console.log(`Dinozaur ${dinosaurId} jest już śledzony.`);
      return this.trackers.get(dinosaurId);
    }

    try {
      // Dynamicznie ładujemy moduł śledzenia dla danego gatunku
      const specificTrackingModule = await this.moduleLoader.load(`./species/${species.toLowerCase()}.js`);

      // Tworzymy i inicjalizujemy tracker dla tego dinozaura
      const tracker = new specificTrackingModule.default(dinosaurId, {
        utils: this.utils,
        core: this.trackingCore
      });

      await tracker.initialize();

      // Zapisujemy tracker i oznaczamy dinozaura jako aktywnego
      this.trackers.set(dinosaurId, tracker);
      this.activeDinosaurs.add(dinosaurId);

      console.log(`Rozpoczęto śledzenie dinozaura ${dinosaurId} (${species}).`);
      return tracker;
    } catch (error) {
      console.error(`Błąd śledzenia dinozaura ${dinosaurId}: `, error);

      // Jeśli nie ma konkretnego modułu dla gatunku, używamy ogólnego
      try {
        console.log(`Próba użycia ogólnego modułu śledzenia dla ${species}`);
        const genericTrackingModule = await this.moduleLoader.load('./genericTracker.js');

        const tracker = new genericTrackingModule.default(dinosaurId, species, {
          utils: this.utils,
          core: this.trackingCore
        });

        await tracker.initialize();

        this.trackers.set(dinosaurId, tracker);
        this.activeDinosaurs.add(dinosaurId);

        console.log(`Rozpoczęto ogólne śledzenie dinozaura ${dinosaurId} (${species}).`);
        return tracker;
      } catch (fallbackError) {
        console.error(`Nie udało się użyć nawet ogólnego modułu śledzenia: `, fallbackError);
        throw new Error(`Nie można śledzić dinozaura ${dinosaurId}: ${error.message}`);
      }
    }
  }

  async stopTracking(dinosaurId) {
    if (!this.trackers.has(dinosaurId)) {
      console.log(`Dinozaur ${dinosaurId} nie jest śledzony.`);
      return false;
    }

    try {
      const tracker = this.trackers.get(dinosaurId);
      await tracker.shutdown();

      this.trackers.delete(dinosaurId);
      this.activeDinosaurs.delete(dinosaurId);

      console.log(`Zatrzymano śledzenie dinozaura ${dinosaurId}.`);
      return true;
    } catch (error) {
      console.error(`Błąd zatrzymania śledzenia dinozaura ${dinosaurId}: `, error);
      return false;
    }
  }

  getActiveTrackingCount() {
    return this.activeDinosaurs.size;
  }

  getTrackerInfo(dinosaurId) {
    const tracker = this.trackers.get(dinosaurId);
    if (!tracker) {
      return null;
    }

    return {
      dinosaurId,
      species: tracker.species,
      lastKnownLocation: tracker.getLastLocation(),
      status: tracker.getStatus(),
      isActive: tracker.isActive()
    };
  }
}

// Użycie systemu śledzenia
async function initTrackingSystem() {
  const trackingSystem = new DinosaurTrackingSystem();
  await trackingSystem.initialize();

  // Śledzenie różnych gatunków dinozaurów
  try {
    const rexTracker = await trackingSystem.trackDinosaur('rex-01', 'tyrannosaurus');
    console.log('Status T-Rexa:', rexTracker.getStatus());

    const raptorTracker = await trackingSystem.trackDinosaur('raptor-02', 'velociraptor');
    console.log('Status Velociraptora:', raptorTracker.getStatus());

    // Nawet jeśli nie mamy specyficznego modułu, system powinien użyć fallbacku
    const stegoTracker = await trackingSystem.trackDinosaur('stego-01', 'stegosaurus');
    console.log('Status Stegozaura:', stegoTracker.getStatus());

    console.log(`Aktywne śledzenie: ${trackingSystem.getActiveTrackingCount()} dinozaurów`);
  } catch (error) {
    console.error(`Błąd inicjalizacji systemu śledzenia: `, error);
  }
}

// Inicjalizacja systemu
initTrackingSystem();

Wady i zalety dynamicznego importowania

Zalety

  1. Mniejsze początkowe obciążenie - Aplikacja ładuje tylko te moduły, które są potrzebne w danym momencie
  2. Lepsza wydajność - Podział kodu (code splitting) pozwala na szybsze ładowanie strony
  3. Elastyczność - Możliwość ładowania modułów w zależności od warunków lub interakcji użytkownika
  4. Warunkowe importy - Możliwość wyboru różnych implementacji w zależności od środowiska, parametrów, itp.
  5. Łatwiejsza konserwacja - Podział aplikacji na mniejsze, niezależne moduły

Wady

  1. Złożoność - Dodaje warstwę złożoności do aplikacji
  2. Obsługa błędów - Wymaga dokładnej obsługi błędów dla przypadków, gdy moduł nie może zostać załadowany
  3. Opóźnienia - Ładowanie modułu w czasie wykonania może wprowadzić opóźnienia w interfejsie użytkownika
  4. Zwiększony rozmiar pakietów - W niektórych przypadkach może prowadzić do duplikacji kodu
  5. Debugowanie - Może być trudniejsze w debugowaniu niż statyczne importy

Implementacja w różnych środowiskach

Przeglądarki

W nowoczesnych przeglądarkach dynamiczny import działa natywnie:

// Przykład dla przeglądarki
document.getElementById('btnActivateLockdown').addEventListener('click', async () => {
  try {
    const lockdownModule = await import('./security/lockdown.js');
    const lockdown = new lockdownModule.default();
    lockdown.activateForSectors(['A1', 'B2']);
  } catch (error) {
    console.error('Nie udało się załadować modułu blokady:', error);
  }
});

Node.js

Node.js od wersji 13.2.0 oficjalnie wspiera dynamiczne importy:

// Przykład dla Node.js
async function runDinosaurAnalysis(species) {
  try {
    // Dynamiczny import modułu analizy dla danego gatunku
    const analyzer = await import(`./analyzers/${species.toLowerCase()}.js`);
    return analyzer.analyzeGenome();
  } catch (error) {
    console.error(`Nie ma analizatora dla gatunku ${species}: `, error);
    // Użyj ogólnego analizatora
    const genericAnalyzer = await import('./analyzers/generic.js');
    return genericAnalyzer.analyzeGenome(species);
  }
}

// Użycie
runDinosaurAnalysis('velociraptor')
  .then(results => console.log('Wyniki analizy genomu:', results))
  .catch(error => console.error('Błąd analizy:', error));

Webpack i inne bundlery

Bundlery jak Webpack, Rollup czy Parcel automatycznie wykrywają dynamiczne importy i dzielą kod na mniejsze fragmenty (chunks):

// Webpack automatycznie zrozumie i obsłuży ten import
const loadAdminPanel = async () => {
  // Zostanie wygenerowany osobny chunk dla adminPanel
  const adminModule = await import(/* webpackChunkName: "admin" */ './adminPanel');
  return new adminModule.default();
};

// Można nawet wskazać priorytet ładowania
const prefetchReportGenerator = () => {
  // Pobierz moduł z wyprzedzeniem, ale wykonaj dopiero gdy potrzebny
  import(/* webpackPrefetch: true */ './reportGenerator');
};

Podsumowanie

Dynamiczne importowanie modułów to potężna funkcja, która pozwala na większą elastyczność i wydajność w aplikacjach JavaScript. W kontekście naszego Parku Jurajskiego, daje nam możliwość budowania systemów, które mogą dynamicznie reagować na różne sytuacje, co jest kluczowe dla bezpieczeństwa parku pełnego niebezpiecznych dinozaurów!

Dzięki dynamicznym importom możemy:

  • Ładować moduły tylko wtedy, gdy są potrzebne
  • Wybierać różne implementacje w zależności od kontekstu
  • Zmniejszyć początkowy czas ładowania aplikacji
  • Tworzyć elastyczne systemy z modułami określanymi w czasie wykonania

W następnym ćwiczeniu zajmiemy się narzędziami do debugowania JavaScript, które będą nieocenione, gdy nastąpi jakaś awaria w naszych systemach zarządzania parkiem!

Kod do tej lekcji: main.js
// Dynamiczne importowanie modułów - Park Jurajski
// Lazy loading i Code Splitting

console.log("Dynamiczne Importowanie Modułów");
console.log("System ładowania na żądanie\n");

// ===========================================
// SYMULACJA DYNAMICZNYCH MODUŁÓW
// ===========================================

// Symulowane moduły jako funkcje
const modules = {
  '/modules/trex-handler.js': () => ({
    name: 'T-Rex Handler Module',
    handleTRex: (trex) => {
      console.log(`Obsługa T-Rexa: ${trex.name}`);
      console.log(`  Poziom zagrożenia: ${trex.dangerLevel}/10`);
      console.log(`  Status: Wymagana podwójna ochrona`);
      return {
        securityLevel: 'MAXIMUM',
        requiredGuards: 4,
        specialEquipment: ['Tranquilizer', 'Electric Fence', 'Tracker']
      };
    }
  }),

  '/modules/herbivore-handler.js': () => ({
    name: 'Herbivore Handler Module',
    handleHerbivore: (dino) => {
      console.log(`Obsługa roślinożercy: ${dino.name}`);
      console.log(`  Poziom zagrożenia: ${dino.dangerLevel}/10`);
      console.log(`  Status: Standardowa ochrona`);
      return {
        securityLevel: 'LOW',
        requiredGuards: 1,
        specialEquipment: ['Food Dispenser', 'Health Monitor']
      };
    }
  }),

  '/modules/raptor-handler.js': () => ({
    name: 'Raptor Handler Module',
    handleRaptor: (raptor) => {
      console.log(`Obsługa Velociraptora: ${raptor.name}`);
      console.log(`  Poziom zagrożenia: ${raptor.dangerLevel}/10`);
      console.log(`  Status: Wysoka czujność - polują stadami!`);
      return {
        securityLevel: 'HIGH',
        requiredGuards: 3,
        specialEquipment: ['Pack Tracker', 'Sound System', 'Emergency Protocol']
      };
    }
  }),

  '/modules/analytics.js': () => ({
    name: 'Analytics Module',
    generateReport: (dinosaurs) => {
      const total = dinosaurs.length;
      const carnivores = dinosaurs.filter(d => d.diet === 'carnivore').length;
      const herbivores = dinosaurs.filter(d => d.diet === 'herbivore').length;
      const avgDanger = dinosaurs.reduce((sum, d) => sum + d.dangerLevel, 0) / total;

      return {
        totalDinosaurs: total,
        carnivores,
        herbivores,
        averageDangerLevel: avgDanger.toFixed(2),
        recommendation: avgDanger > 6 ? 'Zwiększ bezpieczeństwo' : 'Poziom bezpieczeństwa OK'
      };
    }
  }),

  '/modules/emergency.js': () => ({
    name: 'Emergency Protocol Module',
    activateEmergency: (reason) => {
      console.log(`\nPROTOKÓŁ AWARYJNY AKTYWOWANY!`);
      console.log(`Powód: ${reason}`);
      console.log(`1. Zamknięcie wszystkich wybiegów`);
      console.log(`2. Ewakuacja gości`);
      console.log(`3. Mobilizacja ekip bezpieczeństwa`);
      return {
        status: 'ACTIVE',
        timestamp: new Date().toISOString(),
        actions: ['LOCK_ENCLOSURES', 'EVACUATE', 'ALERT_SECURITY']
      };
    }
  })
};

// Symulacja import() dla demonstracji
async function dynamicImport(path) {
  console.log(`⏳ Ładowanie modułu: ${path}...`);

  // Symulacja opóźnienia sieciowego
  await new Promise(resolve => setTimeout(resolve, 500));

  if (modules[path]) {
    const module = modules[path]();
    console.log(`Załadowano: ${module.name}\n`);
    return module;
  }

  throw new Error(`Module not found: ${path}`);
}

// ===========================================
// SYSTEM ZARZĄDZANIA DINOZAURAMI
// ===========================================

class DinosaurManager {
  constructor() {
    this.dinosaurs = [];
    this.loadedModules = new Map();
  }

  addDinosaur(name, species, diet, dangerLevel) {
    const dinosaur = { name, species, diet, dangerLevel };
    this.dinosaurs.push(dinosaur);
    console.log(`Dodano dinozaura: ${name} (${species})`);
    return dinosaur;
  }

  async handleDinosaur(dinosaur) {
    console.log(`\nPrzetwarzanie: ${dinosaur.name}...`);

    // Dynamiczne ładowanie odpowiedniego modułu
    let modulePath;
    let handlerMethod;

    if (dinosaur.species === 'Tyrannosaurus Rex') {
      modulePath = '/modules/trex-handler.js';
      handlerMethod = 'handleTRex';
    } else if (dinosaur.species === 'Velociraptor') {
      modulePath = '/modules/raptor-handler.js';
      handlerMethod = 'handleRaptor';
    } else if (dinosaur.diet === 'herbivore') {
      modulePath = '/modules/herbivore-handler.js';
      handlerMethod = 'handleHerbivore';
    } else {
      console.log(`Brak dedykowanego modułu dla ${dinosaur.species}`);
      return null;
    }

    // Sprawdź cache
    if (!this.loadedModules.has(modulePath)) {
      const module = await dynamicImport(modulePath);
      this.loadedModules.set(modulePath, module);
    } else {
      console.log(`Użyto cached module: ${modulePath}\n`);
    }

    const handler = this.loadedModules.get(modulePath);
    return handler[handlerMethod](dinosaur);
  }

  async generateAnalytics() {
    console.log(`\nGenerowanie raportu analitycznego...`);

    if (!this.loadedModules.has('/modules/analytics.js')) {
      const module = await dynamicImport('/modules/analytics.js');
      this.loadedModules.set('/modules/analytics.js', module);
    }

    const analytics = this.loadedModules.get('/modules/analytics.js');
    return analytics.generateReport(this.dinosaurs);
  }

  async triggerEmergency(reason) {
    const module = await dynamicImport('/modules/emergency.js');
    return module.activateEmergency(reason);
  }
}

// ===========================================
// DEMONSTRACJA
// ===========================================

async function runDemo() {
  console.log("=== START DEMONSTRACJI ===\n");

  const manager = new DinosaurManager();

  // Dodawanie dinozaurów
  console.log("Rejestracja dinozaurów:");
  const trex = manager.addDinosaur('Rexy', 'Tyrannosaurus Rex', 'carnivore', 9);
  const raptor1 = manager.addDinosaur('Blue', 'Velociraptor', 'carnivore', 7);
  const raptor2 = manager.addDinosaur('Charlie', 'Velociraptor', 'carnivore', 7);
  const brachi = manager.addDinosaur('Gentle Giant', 'Brachiosaurus', 'herbivore', 2);
  const trice = manager.addDinosaur('Spike', 'Triceratops', 'herbivore', 3);

  console.log(`\nCałkowita liczba dinozaurów: ${manager.dinosaurs.length}`);

  // Dynamiczne ładowanie modułów dla każdego dinozaura
  console.log("\n=== ŁADOWANIE MODUŁÓW ON-DEMAND ===");

  const trexProtocol = await manager.handleDinosaur(trex);
  console.log('Protokół bezpieczeństwa:', trexProtocol);

  const raptor1Protocol = await manager.handleDinosaur(raptor1);
  console.log('Protokół bezpieczeństwa:', raptor1Protocol);

  const raptor2Protocol = await manager.handleDinosaur(raptor2);
  console.log('Protokół bezpieczeństwa:', raptor2Protocol);

  const brachiProtocol = await manager.handleDinosaur(brachi);
  console.log('Protokół bezpieczeństwa:', brachiProtocol);

  const triceProtocol = await manager.handleDinosaur(trice);
  console.log('Protokół bezpieczeństwa:', triceProtocol);

  // Raport analityczny
  console.log("\n=== ANALITYKA ===");
  const report = await manager.generateAnalytics();
  console.log('\nRaport:', JSON.stringify(report, null, 2));

  // Sytuacja awaryjna
  if (parseFloat(report.averageDangerLevel) > 6) {
    const emergency = await manager.triggerEmergency('Wysoki średni poziom zagrożenia');
    console.log('\nStatus awaryjny:', emergency);
  }

  console.log(`\nZaładowane moduły: ${manager.loadedModules.size}`);
  console.log(`Lista: ${Array.from(manager.loadedModules.keys()).join(', ')}`);

  console.log("\n=== ZALETY DYNAMICZNEGO IMPORTOWANIA ===\n");
  console.log("Lazy Loading:");
  console.log("   - Moduły ładowane tylko gdy potrzebne");
  console.log("   - Szybszy start aplikacji\n");

  console.log("Code Splitting:");
  console.log("   - Mniejsze bundlowanie początkowe");
  console.log("   - Lepsze wykorzystanie pamięci\n");

  console.log("Conditional Loading:");
  console.log("   - Ładowanie na podstawie warunków runtime");
  console.log("   - Elastyczność w zarządzaniu zasobami\n");

  console.log("Caching:");
  console.log("   - Raz załadowany moduł jest cached");
  console.log("   - Szybszy dostęp przy kolejnych wywołaniach\n");

  console.log("=== SKŁADNIA ===\n");
  console.log("// Dynamiczny import zwraca Promise");
  console.log("import('./module.js')");
  console.log("  .then(module => {");
  console.log("    module.doSomething();");
  console.log("  })");
  console.log("  .catch(err => console.error(err));\n");

  console.log("// Lub z async/await");
  console.log("async function loadModule() {");
  console.log("  const module = await import('./module.js');");
  console.log("  module.doSomething();");
  console.log("}\n");

  console.log("Demonstracja zakończona!");
}

// Uruchom demo
runDemo().catch(console.error);

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Zadania praktyczne w grze

  • Klikanie w kolejności

    Ułóż elementy eksportu domyślnego w poprawnej kolejności:

  • Klikanie w kolejności

    Ułóż elementy eksportu modułu JavaScript:

  • Układanie w poziomie

    Ułóż elementy importu modułu JavaScript:

  1. Kliknij w kolejnościSkładnia eksportu ES Module
  2. Kliknij w kolejnościSkładnia eksportu modułu
  3. Ułóż w kolejnościSkładnia importu modułu

Przydatne artykuły