Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript
Konsola przeglądarki i jej funkcje
W tej lekcji7
Zarządzanie Parkiem Jurajskim nie jest łatwym zadaniem. Gdy pojawiają się problemy z systemem śledzenia dinozaurów lub gdy musimy szybko zdiagnozować, dlaczego protokół blokady nie uruchamia się prawidłowo, kluczową umiejętnością jest debugowanie. Jednym z najważniejszych narzędzi diagnostycznych w JavaScript jest konsola przeglądarki.
W tym ćwiczeniu poznamy narzędzie, które będzie Twoim najlepszym przyjacielem podczas poszukiwania i rozwiązywania problemów - konsolę deweloperską przeglądarki.
Otwieranie konsoli deweloperskiej
Zanim zaczniemy wykorzystywać konsolę, musimy wiedzieć, jak ją otworzyć:
- Chrome/Edge: <kbd>F12</kbd> lub <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>J</kbd> (Windows/Linux) lub <kbd>Cmd</kbd>+<kbd>Option</kbd>+<kbd>J</kbd> (Mac)
- Firefox: <kbd>F12</kbd> lub <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>K</kbd> (Windows/Linux) lub <kbd>Cmd</kbd>+<kbd>Option</kbd>+<kbd>K</kbd> (Mac)
- Safari: <kbd>Cmd</kbd>+<kbd>Option</kbd>+<kbd>C</kbd> (musisz najpierw włączyć narzędzia deweloperskie w ustawieniach)
Po otwarciu zobaczysz kilka zakładek, w tym "Console" (Konsola). To właśnie na niej będziemy się skupiać.
Podstawowe funkcje konsoli
1. console.log() - Twój najlepszy przyjaciel
Najczęściej używaną funkcją konsoli jest console.log(). Służy do wyświetlania wartości w konsoli, co jest niezastąpione podczas debugowania:
// Wyświetlanie prostych wartości
console.log("System śledzenia dinozaurów uruchomiony");
console.log(42); // liczba
console.log(true); // wartość boolowska
// Wyświetlanie wielu wartości naraz
const dinosaur = { name: "Rex", type: "T-Rex", status: "contained" };
console.log("Dane dinozaura:", dinosaur, "Aktualizacja:", new Date());
// Łączenie tekstu (interpolacja)
const sector = "B7";
const threat = "wysoki";
console.log(`Wykryto dinozaura w sektorze ${sector}. Poziom zagrożenia: ${threat}`);W przypadku naszego systemu Parku Jurajskiego możemy używać console.log() do śledzenia różnych zdarzeń:
function trackDinosaur(id, location) {
console.log(`Śledzenie dinozaura #${id} w lokalizacji ${location}`);
// Logika śledzenia...
const status = checkContainment(id);
if (status !== "contained") {
console.log(`ALERT: Dinozaur #${id} nie jest w wybiegu! Aktualny status: ${status}`);
}
return status;
}2. console.error(), console.warn(), console.info()
Oprócz standardowego log, mamy specjalne metody dla różnych poziomów komunikatów:
// Błędy - zwykle pokazywane na czerwono
console.error("KRYTYCZNY BŁĄD: Awaria systemu ogrodzeń w sektorze T-Rex!");
// Ostrzeżenia - zwykle pokazywane na żółto
console.warn("Ostrzeżenie: Poziom naładowania baterii w czujnikach ruchu spada poniżej 20%");
// Informacje - często wyróżnione od zwykłych logów
console.info("Informacja: Zaplanowano przegląd techniczny systemu na jutro, 8:00");Ich używanie pomaga wizualnie rozróżnić typy komunikatów w konsoli, co jest szczególnie ważne, gdy mamy do czynienia z dużą ilością logów.
3. console.table() - Przejrzyste wyświetlanie danych tabelarycznych
Gdy mamy do czynienia z tablicami obiektów, console.table() jest niezastąpiony:
// Tablica dinozaurów w naszym parku
const dinosaurs = [
{ id: 1, name: "Rex", species: "T-Rex", danger: 9, location: "Wybieg A" },
{ id: 2, name: "Blue", species: "Velociraptor", danger: 8, location: "Wybieg B" },
{ id: 3, name: "Delta", species: "Velociraptor", danger: 8, location: "Wybieg B" },
{ id: 4, name: "Echo", species: "Velociraptor", danger: 7, location: "Wybieg B" },
{ id: 5, name: "Trike", species: "Triceratops", danger: 4, location: "Wybieg C" }
];
// Wyświetla piękną tabelę z danymi
console.table(dinosaurs);
// Możemy też wybrać tylko niektóre kolumny
console.table(dinosaurs, ["name", "species", "danger"]);Jest to szczególnie przydatne przy analizie danych, sprawdzaniu wyników zapytań API czy przeglądaniu konfiguracji.
4. console.group() - Grupowanie logów
Gdy mamy wiele powiązanych logów, możemy je zgrupować dla przejrzystości:
// Monitorowanie konkretnego dinozaura
function monitorDinosaur(dinosaur) {
console.group(`Monitoring: ${dinosaur.name} (${dinosaur.species})`);
console.log(`Lokalizacja: ${dinosaur.location}`);
console.log(`Poziom zagrożenia: ${dinosaur.danger}/10`);
const healthStatus = checkHealth(dinosaur.id);
console.log(`Stan zdrowia: ${healthStatus.status}`);
if (healthStatus.issues.length > 0) {
console.warn(`Wykryto problemy zdrowotne: ${healthStatus.issues.join(', ')}`);
}
const securityStatus = checkSecurity(dinosaur.location);
console.log(`Stan zabezpieczeń: ${securityStatus.status}`);
if (securityStatus.issues.length > 0) {
console.error(`Problemy z zabezpieczeniami: ${securityStatus.issues.join(', ')}`);
}
console.groupEnd();
return { healthStatus, securityStatus };
}
// Grupowanie można również zagnieżdżać
function monitorAllDinosaurs(dinosaurs) {
console.group('Monitoring wszystkich dinozaurów');
dinosaurs.forEach(dino => {
monitorDinosaur(dino);
});
console.groupEnd();
}
monitorAllDinosaurs(dinosaurs);Grupowanie można również zacząć jako zwinięte, używając console.groupCollapsed(), co jest przydatne przy dużej liczbie grup.
5. console.time() i console.timeEnd() - Mierzenie czasu wykonania
Czasem potrzebujemy wiedzieć, jak długo trwa wykonanie pewnych operacji:
// Mierzenie czasu ładowania modułu
console.time('Ładowanie modułu śledzenia');
loadTrackingModule()
.then(() => {
console.timeEnd('Ładowanie modułu śledzenia');
// Wyświetli np.: "Ładowanie modułu śledzenia: 235.41ms"
});
// Możemy mieć wiele równoległych timerów
console.time('Inicjalizacja systemu');
console.time('Przetwarzanie danych');
initSystem()
.then(() => {
console.timeEnd('Inicjalizacja systemu');
return processData();
})
.then(() => {
console.timeEnd('Przetwarzanie danych');
});Jest to niezwykle przydatne do identyfikacji wąskich gardeł w aplikacji i optymalizacji wydajności.
6. console.trace() - Śledzenie stosu wywołań
Gdy nie wiesz, skąd dokładnie została wywołana funkcja:
function monitorFenceStatus(sectorId) {
console.trace(`Sprawdzanie statusu ogrodzenia w sektorze ${sectorId}`);
// Reszta kodu...
}
function checkAllFences() {
const sectors = ['A1', 'B2', 'C3'];
sectors.forEach(monitorFenceStatus);
}
function dailySecurityCheck() {
checkAllFences();
}
dailySecurityCheck();console.trace() wyświetli pełny stos wywołań funkcji, pokazując dokładną ścieżkę wykonania, co jest nieocenione przy debugowaniu skomplikowanych wywołań.
7. console.assert() - Warunkowe komunikaty debugowania
Sprawdza warunek i wyświetla błąd, gdy warunek jest fałszywy:
function feedDinosaur(dinosaur, foodAmount) {
// Upewniamy się, że ilość jedzenia jest wystarczająca dla danego gatunku
console.assert(
foodAmount >= getMinimumFoodRequirement(dinosaur.species),
`Niewystarczająca ilość jedzenia dla ${dinosaur.name}! ` +
`Wymagane minimum: ${getMinimumFoodRequirement(dinosaur.species)}kg, ` +
`Dostarczono: ${foodAmount}kg`
);
// Reszta kodu...
}
feedDinosaur(dinosaurs[0], 5); // Jeśli 5kg to za mało, zobaczymy błądJest to przydatne do wczesnegowykrywania potencjalnych problemów, bez przerywania działania programu.
8. console.count() - Liczenie wywołań
Liczenie, ile razy dana funkcja lub blok kodu został wywołany:
function checkFenceVoltage(sectorId) {
console.count(`Sprawdzenie napięcia w sektorze ${sectorId}`);
// Reszta kodu...
}
// Symulacja regularnego sprawdzania
setInterval(() => checkFenceVoltage('A1'), 5000);
setInterval(() => checkFenceVoltage('B2'), 8000);Po każdym wywołaniu zobaczymy w konsoli coś w rodzaju:
Sprawdzenie napięcia w sektorze A1: 1
Sprawdzenie napięcia w sektorze A1: 2
Sprawdzenie napięcia w sektorze B2: 1
Sprawdzenie napięcia w sektorze A1: 3Możemy zresetować licznik używając console.countReset('nazwa').
9. console.dir() - Wyświetlanie właściwości obiektu
Gdy chcemy zobaczyć pełną strukturę obiektu:
const parkSystem = {
name: "Jurassic Park",
sectors: {
A: { dinosaurs: [/*...*/], status: "secure" },
B: { dinosaurs: [/*...*/], status: "alert" },
//
},
security: {
fences: { status: "online", voltage: 10000 },
cameras: { operational: 45, offline: 3 },
//
},
//
};
// Wyświetla interaktywną, rozwijaną strukturę obiektu
console.dir(parkSystem);Ta funkcja jest szczególnie przydatna dla złożonych obiektów, gdyż pozwala na przeglądanie zagnieżdżonych właściwości.
10. Formatowanie komunikatów w konsoli
Konsola obsługuje również podstawowe formatowanie za pomocą specyfikatorów:
// Formatowanie tekstu z różnymi stylami CSS
console.log(
"%cUWAGA! %cPoziom zagrożenia krytyczny %cin sektorze B!",
"color: red; font-size: 20px; font-weight: bold;",
"color: orange; font-size: 16px;",
"color: black; font-weight: bold;"
);
// Wyświetlanie zmiennych w komunikacie
console.log("Dinozaur %s ma poziom zagrożenia %d", "Rex", 9);Zaawansowane funkcje konsoli
1. Filtrowanie komunikatów
Większość konsoli przeglądarek pozwala na filtrowanie wyświetlanych komunikatów. Możemy filtrować według:
- Poziomu (Error, Warning, Info, Log)
- Tekstu (wpisując frazę do wyszukania)
- Źródła (np. tylko z określonego pliku)
Jest to niezwykle przydatne, gdy mamy do czynienia z dużą ilością logów.
2. Zapisywanie do pliku
Komunikaty z konsoli możemy zazwyczaj zapisać do pliku, co jest przydatne do analizy logów:
- Kliknij prawym przyciskiem myszy w konsoli
- Wybierz "Save as..." lub "Zapisz jako..."
3. Czyszczenie konsoli
Konsolę można wyczyścić na kilka sposobów:
- Kliknięcie ikony przekreślonego koła w konsoli
- Naciśnięcie <kbd>Ctrl</kbd>+<kbd>L</kbd> (gdy konsola jest aktywna)
- Użycie kodu:
console.clear()
4. Konsola jako środowisko REPL
Konsola przeglądarki działa również jako REPL (Read-Eval-Print Loop), co oznacza, że możemy bezpośrednio wykonywać w niej kod JavaScript:
// Bezpośrednio w konsoli
const dinos = [{name: "Rex"}, {name: "Blue"}];
dinos.filter(d => d.name === "Blue");
// Definiowanie funkcji
function alertSecurity(message) {
return `[SECURITY ALERT] ${message} - ${new Date().toISOString()}`;
}
// Używanie tej funkcji
alertSecurity("Naruszenie ogrodzenia w sektorze C2");Jest to niezwykle przydatne do testowania małych fragmentów kodu czy debugowania bez modyfikowania kodu źródłowego.
Praktyczna implementacja w naszym systemie Parku Jurajskiego
Stwórzmy praktyczną implementację systemu logowania dla naszego Parku Jurajskiego, który wykorzysta różne funkcje konsoli:
// Logger dla systemu Parku Jurajskiego
class JurassicLogger {
constructor(moduleName) {
this.moduleName = moduleName;
this.logCount = 0;
this.errorCount = 0;
this.warnCount = 0;
}
log(...args) {
this.logCount++;
console.log(`[${this.moduleName}] `, ...args);
}
error(...args) {
this.errorCount++;
console.error(`[${this.moduleName}] ERROR:`, ...args);
}
warn(...args) {
this.warnCount++;
console.warn(`[${this.moduleName}] WARNING:`, ...args);
}
info(...args) {
console.info(`[${this.moduleName}] INFO:`, ...args);
}
startGroup(label) {
console.group(`[${this.moduleName}] ${label}`);
}
endGroup() {
console.groupEnd();
}
startTimer(label) {
console.time(`[${this.moduleName}] ${label}`);
}
endTimer(label) {
console.timeEnd(`[${this.moduleName}] ${label}`);
}
table(data, columns) {
console.log(`[${this.moduleName}] Dane tabelaryczne:`);
console.table(data, columns);
}
getStats() {
return {
moduleName: this.moduleName,
logs: this.logCount,
errors: this.errorCount,
warnings: this.warnCount
};
}
trace(message) {
console.log(`[${this.moduleName}] TRACE: ${message}`);
console.trace();
}
assert(condition, message) {
console.assert(condition, `[${this.moduleName}] Assertion failed: ${message}`);
}
// Formatowanie specjalne dla alertów bezpieczeństwa
securityAlert(message, level = 'warning') {
const styles = {
warning: "background: #FFA500; color: black; padding: 2px 5px; border-radius: 3px;",
critical: "background: #FF0000; color: white; padding: 2px 5px; border-radius: 3px; font-weight: bold;",
info: "background: #0066FF; color: white; padding: 2px 5px; border-radius: 3px;"
};
console.log(
`%c[${this.moduleName}] SECURITY ALERT %c${message}`,
styles[level] || styles.warning,
"color: black;"
);
}
}
// Przykład użycia
const securityLogger = new JurassicLogger('ParkSecurity');
const dinosaurLogger = new JurassicLogger('DinosaurTracker');
const systemLogger = new JurassicLogger('MainSystem');
// Inicjalizacja systemu
systemLogger.startTimer('Inicjalizacja systemu');
systemLogger.log('Rozpoczynanie inicjalizacji systemów Parku Jurajskiego...');
// Symulacja inicjalizacji podsystemów
setTimeout(() => {
systemLogger.info('Podsystemy uruchomione');
systemLogger.endTimer('Inicjalizacja systemu');
// Informacje o dinozaurach
const dinoData = [
{ id: 'TRX-01', name: 'Rex', species: 'T-Rex', status: 'contained', healthLevel: 92 },
{ id: 'VEL-01', name: 'Blue', species: 'Velociraptor', status: 'contained', healthLevel: 87 },
{ id: 'VEL-02', name: 'Delta', species: 'Velociraptor', status: 'sedated', healthLevel: 65 },
{ id: 'TRI-01', name: 'Sarah', species: 'Triceratops', status: 'contained', healthLevel: 95 }
];
dinosaurLogger.startGroup('Raport statusu dinozaurów');
dinosaurLogger.table(dinoData);
// Sprawdzanie stanu zdrowia dinozaurów
dinoData.forEach(dino => {
dinosaurLogger.startGroup(`Dinozaur: ${dino.name}`);
if (dino.healthLevel < 70) {
dinosaurLogger.warn(`Poziom zdrowia dinozaura ${dino.name} jest niski: ${dino.healthLevel}%`);
} else {
dinosaurLogger.log(`Stan zdrowia: ${dino.healthLevel}%`);
}
if (dino.status !== 'contained') {
dinosaurLogger.error(`Dinozaur ${dino.name} nie jest w wybiegu! Status: ${dino.status}`);
securityLogger.securityAlert(`Dinozaur ${dino.name} (${dino.species}) ma status: ${dino.status}`, 'critical');
}
dinosaurLogger.endGroup();
});
dinosaurLogger.endGroup();
// Sprawdzanie systemów bezpieczeństwa
securityLogger.startGroup('Systemy bezpieczeństwa');
const fenceStatus = { sector: 'B', voltage: 9800, status: 'active' };
securityLogger.log(`Status ogrodzenia w sektorze ${fenceStatus.sector}: ${fenceStatus.status}`);
securityLogger.assert(
fenceStatus.voltage >= 10000,
`Napięcie ogrodzenia w sektorze ${fenceStatus.sector} jest zbyt niskie: ${fenceStatus.voltage}V (min. 10000V)`
);
// Symulacja naruszenia bezpieczeństwa
if (Math.random() > 0.7) {
securityLogger.trace('Wykryto nieautoryzowany dostęp do panelu sterowania');
securityLogger.securityAlert('Wykryto nieautoryzowany dostęp do systemów kontroli!', 'critical');
}
securityLogger.endGroup();
// Wyświetlanie statystyk logów
systemLogger.startGroup('Statystyki logów');
console.table([
securityLogger.getStats(),
dinosaurLogger.getStats(),
systemLogger.getStats()
]);
systemLogger.endGroup();
}, 2000);Integracja z frameworkami
Nowoczesne frameworki jak React czy Vue mają własne integracje z konsolą, które dostarczają dodatkowych informacji debugujących:
React DevTools
React DevTools dodaje do konsoli przeglądarki specjalne narzędzia do inspekcji komponentów React, stanu, propów i drzewa komponentów. To niezastąpione narzędzie dla każdego dewelopera React.
Vue DevTools
Podobnie Vue ma własne narzędzia deweloperskie, które pozwalają na inspekcję komponentów, stanu Vuex i innych aspektów aplikacji Vue.
Logowanie produkcyjne i deweloperskie
W rzeczywistych aplikacjach warto rozdzielić logowanie deweloperskie od produkcyjnego:
// logger.js
class Logger {
constructor(isProduction = process.env.NODE_ENV === 'production') {
this.isProduction = isProduction;
}
log(...args) {
if (!this.isProduction) {
console.log(...args);
}
}
// W przypadku błędów krytycznych, logujemy nawet na produkcji
error(...args) {
console.error(...args);
if (this.isProduction) {
// Na produkcji możemy wysłać błędy do usługi monitorowania
this.sendToErrorMonitoring(args);
}
}
// ...inne metody
sendToErrorMonitoring(errorData) {
// Implementacja wysyłania do Sentry, LogRocket itp.
}
}
export default new Logger();Podsumowanie
Konsola przeglądarki to potężne narzędzie, które znacznie ułatwia debugowanie i monitorowanie aplikacji JavaScript. W kontekście naszego Parku Jurajskiego, dobre praktyki logowania mogą być różnicą między sprawnie działającym parkiem a... cóż, scenariuszem znanym z filmów!
Najważniejsze funkcje do zapamiętania:
console.log()- podstawowe logowanieconsole.error(),console.warn(),console.info()- różne poziomy komunikatówconsole.table()- przejrzyste wyświetlanie danychconsole.group()- organizacja powiązanych logówconsole.time()iconsole.timeEnd()- mierzenie wydajnościconsole.trace()- diagnozowanie skąd pochodzi wywołanieconsole.assert()- warunkowe komunikaty debugowania
Pamiętaj, aby regularnie używać konsoli podczas tworzenia aplikacji - pomoże Ci to szybciej wykrywać i naprawiać błędy, zanim dinozaury znajdą lukę w Twoim kodzie!
Kod do tej lekcji: main.js
// Re-exportowanie i agregacja modułów - Park Jurajski
// Tworzenie "index" modułów dla łatwiejszego importowania
console.log("Re-exportowanie i Agregacja Modułów");
console.log("Organizacja struktury modułów\n");
// ===========================================
// MODUŁY BAZOWE
// ===========================================
// === types/DinosaurTypes.js ===
const DinosaurTypes = {
CARNIVORE: 'carnivore',
HERBIVORE: 'herbivore',
OMNIVORE: 'omnivore'
};
const DangerLevels = {
LOW: 1,
MEDIUM: 5,
HIGH: 7,
CRITICAL: 9
};
// === models/Dinosaur.js ===
class Dinosaur {
constructor(name, species, type, dangerLevel) {
this.name = name;
this.species = species;
this.type = type;
this.dangerLevel = dangerLevel;
this.health = 100;
this.id = Math.random().toString(36).substr(2, 9);
}
getInfo() {
return `${this.name} (${this.species}) - Danger: ${this.dangerLevel}/10`;
}
}
// === models/Enclosure.js ===
class Enclosure {
constructor(id, name, capacity) {
this.id = id;
this.name = name;
this.capacity = capacity;
this.dinosaurs = [];
}
addDinosaur(dinosaur) {
if (this.dinosaurs.length >= this.capacity) {
throw new Error('Enclosure is full');
}
this.dinosaurs.push(dinosaur);
}
getStatus() {
return `${this.name}: ${this.dinosaurs.length}/${this.capacity} dinosaurs`;
}
}
// === models/Visitor.js ===
class Visitor {
constructor(name, age, ticketType) {
this.name = name;
this.age = age;
this.ticketType = ticketType;
this.id = Math.random().toString(36).substr(2, 9);
}
getDetails() {
return `${this.name}, ${this.age} years old (${this.ticketType} ticket)`;
}
}
// === utils/validators.js ===
function validateDinosaur(data) {
const { name, species, type, dangerLevel } = data;
const errors = [];
if (!name || typeof name !== 'string') errors.push('Invalid name');
if (!species || typeof species !== 'string') errors.push('Invalid species');
if (!Object.values(DinosaurTypes).includes(type)) errors.push('Invalid type');
if (dangerLevel < 1 || dangerLevel > 10) errors.push('Danger level must be 1-10');
return { valid: errors.length === 0, errors };
}
function validateEnclosure(data) {
const { id, name, capacity } = data;
const errors = [];
if (!id || typeof id !== 'string') errors.push('Invalid id');
if (!name || typeof name !== 'string') errors.push('Invalid name');
if (!capacity || capacity < 1) errors.push('Capacity must be at least 1');
return { valid: errors.length === 0, errors };
}
// === utils/formatters.js ===
function formatDinosaurReport(dinosaur) {
return {
id: dinosaur.id,
name: dinosaur.name,
species: dinosaur.species,
type: dinosaur.type,
dangerLevel: dinosaur.dangerLevel,
health: `${dinosaur.health}%`,
status: dinosaur.health > 70 ? 'Good' : 'Needs attention'
};
}
function formatEnclosureReport(enclosure) {
return {
id: enclosure.id,
name: enclosure.name,
occupancy: `${enclosure.dinosaurs.length}/${enclosure.capacity}`,
dinosaurs: enclosure.dinosaurs.map(d => d.name),
status: enclosure.dinosaurs.length >= enclosure.capacity ? 'Full' : 'Available'
};
}
// ===========================================
// MODUŁY AGREGUJĄCE (BARREL EXPORTS)
// ===========================================
// === models/index.js - Agregacja wszystkich modeli ===
// Re-export wszystkich modeli z jednego miejsca
const ModelsModule = {
Dinosaur,
Enclosure,
Visitor
};
console.log("Models Module:");
console.log(" - Dinosaur");
console.log(" - Enclosure");
console.log(" - Visitor\n");
// === types/index.js - Agregacja typów ===
const TypesModule = {
DinosaurTypes,
DangerLevels
};
console.log("Types Module:");
console.log(" - DinosaurTypes");
console.log(" - DangerLevels\n");
// === utils/index.js - Agregacja utilities ===
const UtilsModule = {
// validators
validateDinosaur,
validateEnclosure,
// formatters
formatDinosaurReport,
formatEnclosureReport
};
console.log("Utils Module:");
console.log(" - validateDinosaur");
console.log(" - validateEnclosure");
console.log(" - formatDinosaurReport");
console.log(" - formatEnclosureReport\n");
// === index.js - GŁÓWNY MODUŁ AGREGUJĄCY ===
// Re-export wszystkiego z podmodułów
const JurassicParkSDK = {
// Models
...ModelsModule,
// Types
...TypesModule,
// Utils
...UtilsModule
};
console.log("Main SDK Module (All exports):");
console.log(" All models");
console.log(" All types");
console.log(" All utilities\n");
// ===========================================
// DEMONSTRACJA UŻYCIA
// ===========================================
console.log("=== DEMONSTRACJA RE-EXPORTOWANIA ===\n");
// Zamiast importować z wielu miejsc:
console.log("BEZ re-exportów (wiele importów):");
console.log("import { Dinosaur } from './models/Dinosaur.js';");
console.log("import { Enclosure } from './models/Enclosure.js';");
console.log("import { DinosaurTypes } from './types/DinosaurTypes.js';");
console.log("import { validateDinosaur } from './utils/validators.js';");
console.log("import { formatDinosaurReport } from './utils/formatters.js';\n");
// Możemy importować wszystko z jednego miejsca:
console.log("Z re-exportami (jeden import):");
console.log("import {");
console.log(" Dinosaur, Enclosure,");
console.log(" DinosaurTypes,");
console.log(" validateDinosaur, formatDinosaurReport");
console.log("} from './index.js';\n");
console.log("=== PRAKTYCZNE UŻYCIE ===\n");
// Tworzenie dinozaura
const dinoData = {
name: 'Rexy',
species: 'Tyrannosaurus Rex',
type: JurassicParkSDK.DinosaurTypes.CARNIVORE,
dangerLevel: JurassicParkSDK.DangerLevels.CRITICAL
};
console.log("1. Walidacja danych dinozaura:");
const validation = JurassicParkSDK.validateDinosaur(dinoData);
console.log(` Valid: ${validation.valid}`);
if (validation.valid) {
const trex = new JurassicParkSDK.Dinosaur(
dinoData.name,
dinoData.species,
dinoData.type,
dinoData.dangerLevel
);
console.log(`\n2. Utworzono dinozaura: ${trex.getInfo()}`);
const report = JurassicParkSDK.formatDinosaurReport(trex);
console.log("\n3. Raport dinozaura:");
console.log(JSON.stringify(report, null, 2));
}
// Tworzenie wybiegu
console.log("\n4. Tworzenie wybiegu:");
const enclosureData = {
id: 'ENC-001',
name: 'T-Rex Paddock',
capacity: 2
};
const encValidation = JurassicParkSDK.validateEnclosure(enclosureData);
console.log(` Valid: ${encValidation.valid}`);
if (encValidation.valid) {
const paddock = new JurassicParkSDK.Enclosure(
enclosureData.id,
enclosureData.name,
enclosureData.capacity
);
const trex = new JurassicParkSDK.Dinosaur(
'Rexy',
'T-Rex',
JurassicParkSDK.DinosaurTypes.CARNIVORE,
9
);
paddock.addDinosaur(trex);
const encReport = JurassicParkSDK.formatEnclosureReport(paddock);
console.log("\n5. Raport wybiegu:");
console.log(JSON.stringify(encReport, null, 2));
}
console.log("\n=== ZALETY RE-EXPORTOWANIA ===\n");
console.log("Uproszczone importy:");
console.log(" - Jeden import zamiast wielu");
console.log(" - Czystszy kod\n");
console.log("Lepsze DX (Developer Experience):");
console.log(" - Łatwiejsze odkrywanie API");
console.log(" - Intuicyjna struktura\n");
console.log("Łatwiejsze refaktoryzowanie:");
console.log(" - Zmiany wewnętrznej struktury nie wpływają na użytkowników");
console.log(" - Publiczne API pozostaje stabilne\n");
console.log("Tree Shaking:");
console.log(" - Bundlery potrafią usunąć nieużywany kod");
console.log(" - Mniejszy rozmiar bundla\n");
console.log("=== PRZYKŁADOWE WZORCE ===\n");
console.log("// Podstawowy re-export");
console.log("export { Dinosaur } from './Dinosaur.js';\n");
console.log("// Re-export z aliasem");
console.log("export { Dinosaur as Dino } from './Dinosaur.js';\n");
console.log("// Re-export wszystkiego");
console.log("export * from './models.js';\n");
console.log("// Re-export z agregacją");
console.log("export { Dinosaur } from './Dinosaur.js';");
console.log("export { Enclosure } from './Enclosure.js';");
console.log("export { Visitor } from './Visitor.js';\n");
console.log("// Mixed export (default + named)");
console.log("export { default as Dinosaur, DinosaurTypes } from './Dinosaur.js';\n");
console.log("Demonstracja 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. Które narzędzie w przeglądarce pozwala mierzyć czas wykonania fragmentu kodu JavaScript?