Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript
Dynamiczne importowanie modułów
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
- Mniejsze początkowe obciążenie - Aplikacja ładuje tylko te moduły, które są potrzebne w danym momencie
- Lepsza wydajność - Podział kodu (code splitting) pozwala na szybsze ładowanie strony
- Elastyczność - Możliwość ładowania modułów w zależności od warunków lub interakcji użytkownika
- Warunkowe importy - Możliwość wyboru różnych implementacji w zależności od środowiska, parametrów, itp.
- Łatwiejsza konserwacja - Podział aplikacji na mniejsze, niezależne moduły
Wady
- Złożoność - Dodaje warstwę złożoności do aplikacji
- Obsługa błędów - Wymaga dokładnej obsługi błędów dla przypadków, gdy moduł nie może zostać załadowany
- Opóźnienia - Ładowanie modułu w czasie wykonania może wprowadzić opóźnienia w interfejsie użytkownika
- Zwiększony rozmiar pakietów - W niektórych przypadkach może prowadzić do duplikacji kodu
- 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: