Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript

Konsola przeglądarki i jej funkcje

10 min czytania ·
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łąd

Jest 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: 3

Moż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:

  1. Kliknij prawym przyciskiem myszy w konsoli
  2. 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 logowanie
  • console.error(), console.warn(), console.info() - różne poziomy komunikatów
  • console.table() - przejrzyste wyświetlanie danych
  • console.group() - organizacja powiązanych logów
  • console.time() i console.timeEnd() - mierzenie wydajności
  • console.trace() - diagnozowanie skąd pochodzi wywołanie
  • console.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. 1. Które narzędzie w przeglądarce pozwala mierzyć czas wykonania fragmentu kodu JavaScript?

  1. PytanieNarzędzia konsoli do debugowania

Przydatne artykuły