Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript
CommonJS (require/module.exports)
W tej lekcji11
W poprzednim ćwiczeniu poznaliśmy ES Modules - nowoczesny system modułów w JavaScript. Teraz zagłębimy się w inny, starszy, ale wciąż bardzo ważny system modułów: CommonJS. Choć nasz Park Jurajski potrzebuje najnowszych technologii do monitorowania dinozaurów w przeglądarce, jego solidne zaplecze serwerowe opiera się na Node.js, gdzie dominuje właśnie CommonJS.
Czym jest CommonJS?
CommonJS to system modułów, który został stworzony głównie z myślą o środowisku serwerowym i stał się standardem w ekosystemie Node.js. Zapewnia sposób na organizację kodu JavaScript w odrębne moduły, podobnie jak ES Modules, ale z inną składnią i logiką działania.
W przeciwieństwie do ES Modules, które zostały dodane do języka JavaScript dopiero w ES6 (2015), CommonJS istniał wcześniej i stał się de facto standardem dla Node.js. Nawet teraz, mimo oficjalnego wsparcia dla ES Modules w Node.js, CommonJS pozostaje dominującym formatem dla modułów Node.js i w ekosystemie npm.
Podstawy CommonJS
Główne koncepcje CommonJS to:
- Funkcja
require()do importowania modułów - Obiekt
module.exportslubexportsdo eksportowania elementów
Przyjrzyjmy się, jak te elementy działają w kontekście naszego systemu Parku Jurajskiego.
Eksportowanie elementów w CommonJS
1. Eksportowanie przez przypisanie do module.exports
Najprostszy sposób eksportowania to przypisanie wartości do module.exports:
// dinosaur.js - Model dinozaura
class Dinosaur {
constructor(name, species, diet, dangerLevel) {
this.name = name;
this.species = species;
this.diet = diet;
this.dangerLevel = dangerLevel;
this.health = 100;
this.isContained = true;
}
feed() {
this.health = Math.min(100, this.health + 20);
return `${this.name} został nakarmiony. Poziom zdrowia: ${this.health}%`;
}
checkStatus() {
return {
name: this.name,
health: this.health,
isContained: this.isContained,
warning: this.dangerLevel > 7 ? "WYSOKI POZIOM ZAGROŻENIA" : ""
};
}
}
// Eksport całej klasy
module.exports = Dinosaur;2. Eksportowanie obiektu z wieloma elementami
Możemy również eksportować wiele elementów, przypisując obiekt do module.exports:
// securityUtils.js - Narzędzia do obsługi bezpieczeństwa
const SECURITY_LEVELS = {
GREEN: "normalny",
YELLOW: "podwyższony",
ORANGE: "wysoki",
RED: "krytyczny"
};
function checkFenceStatus(sectorId) {
// Symulacja sprawdzania statusu ogrodzenia w danym sektorze
const status = Math.random() > 0.1 ? "active" : "failure";
return {
sector: sectorId,
status,
timestamp: new Date().toISOString()
};
}
function triggerAlarm(sector, reason) {
console.log(`ALARM! Sektor ${sector}: ${reason}`);
// Logika uruchamiania alarmu
return {
success: true,
alarmId: "ALR-" + Math.floor(Math.random() * 10000)
};
}
function getSecurityStatus() {
// Zwraca ogólny status bezpieczeństwa parku
return {
level: SECURITY_LEVELS.GREEN,
activeAlarms: 0,
lastChecked: new Date().toISOString()
};
}
// Eksportowanie wielu elementów jako obiekt
module.exports = {
SECURITY_LEVELS,
checkFenceStatus,
triggerAlarm,
getSecurityStatus
};3. Stopniowe dodawanie do exports
Możemy też dodawać eksporty pojedynczo, używając obiektu exports (który jest referencją do module.exports):
// parkStats.js - Statystyki Parku Jurajskiego
let totalVisitors = 0;
let revenue = 0;
const incidents = [];
// Eksport pierwszej funkcji
exports.addVisitors = function(count) {
totalVisitors += count;
return totalVisitors;
};
// Eksport drugiej funkcji
exports.addRevenue = function(amount) {
revenue += amount;
return revenue;
};
// Eksport trzeciej funkcji
exports.recordIncident = function(type, location, description) {
const incident = {
id: incidents.length + 1,
type,
location,
description,
timestamp: new Date().toISOString()
};
incidents.push(incident);
return incident;
};
// Eksport czwartej funkcji
exports.getDailyStats = function() {
return {
totalVisitors,
revenue,
incidentCount: incidents.length
};
};UWAGA: Należy pamiętać, że exports jest tylko referencją do module.exports. Jeśli przypisujemy coś bezpośrednio do module.exports, tracimy tę referencję, dlatego nie możemy mieszać tych stylów w jednym pliku:
// To NIE zadziała
exports.someFunction = function() { /* ... */ };
module.exports = SomeClass; // To nadpisuje poprzedni eksport
// To zadziała
exports.someFunction = function() { /* ... */ };
exports.SomeClass = SomeClass;
// To też zadziała
module.exports.someFunction = function() { /* ... */ };
module.exports.SomeClass = SomeClass;
// I to zadziała (przypisanie całego obiektu)
module.exports = {
someFunction: function() { /* ... */ },
SomeClass: SomeClass
};Importowanie modułów w CommonJS
1. Importowanie całego modułu
// app.js
const Dinosaur = require('./dinosaur.js');
// Tworzymy nowe instancje dinozaurów
const trex = new Dinosaur("Rex", "Tyrannosaurus", "carnivore", 9);
const brachi = new Dinosaur("Longneck", "Brachiosaurus", "herbivore", 4);
console.log(trex.checkStatus());
console.log(brachi.feed());2. Importowanie i destrukturyzacja obiektu
// securityMonitor.js
const security = require('./securityUtils.js');
// Używamy importowanych funkcji i stałych z obiektu
function monitorSecurity() {
const sectors = ["A1", "B2", "C3", "D4"];
// Sprawdzamy każdy sektor
sectors.forEach(sector => {
const fenceStatus = security.checkFenceStatus(sector);
if (fenceStatus.status === "failure") {
const alarmResult = security.triggerAlarm(
sector,
"Awaria ogrodzenia elektrycznego!"
);
console.log(`Alarm ${alarmResult.alarmId} uruchomiony w sektorze ${sector}`);
// Aktualizacja statusu bezpieczeństwa
console.log("Zmiana poziomu bezpieczeństwa na:", security.SECURITY_LEVELS.RED);
}
});
}
setInterval(monitorSecurity, 60000); // Sprawdzanie co minutę3. Destrukturyzacja przy imporcie
W nowszych wersjach Node.js możemy również używać destrukturyzacji bezpośrednio przy imporcie:
// dashboard.js
const { checkFenceStatus, triggerAlarm, SECURITY_LEVELS } = require('./securityUtils.js');
// Teraz możemy używać funkcji bezpośrednio
function checkAllSectors() {
["A1", "B2", "C3", "D4"].forEach(sector => {
console.log(`Sprawdzanie sektora ${sector}: `, checkFenceStatus(sector));
// Używamy zaimportowanej stałej
if (Math.random() < 0.1) {
console.log(`Ustawianie poziomu bezpieczeństwa: ${SECURITY_LEVELS.ORANGE}`);
}
});
}Różnice między CommonJS a ES Modules
Warto zrozumieć kluczowe różnice między CommonJS a ES Modules:
| Cecha | CommonJS | ES Modules |
|---|---|---|
| Składnia importu | require() | import ... from ... |
| Składnia eksportu | module.exports = ... lub exports.x = ... | export ... lub export default ... |
| Ładowanie | Synchroniczne | Asynchroniczne (ładowane przed wykonaniem) |
| Wykonanie | Kod wykonywany przy każdym imporcie | Kod wykonywany tylko raz, następnie moduł jest buforowany |
| Statyczna analiza | Nie wspiera statycznej analizy (dynamiczne ścieżki) | Wspiera statyczną analizę (ścieżki są statyczne) |
| Wsparcie w przeglądarce | Nie wspierane natywnie | Wspierane w nowoczesnych przeglądarkach |
| Hoisting | Importy nie są hoistowane | Importy są hoistowane (można używać przed deklaracją) |
| Tree-shaking | Trudniejszy do zaimplementowania | Łatwiejszy dzięki statycznej analizie |
Struktura projektu Node.js (backend Parku Jurajskiego)
Teraz przyjrzyjmy się, jak moglibyśmy zorganizować backend naszego systemu zarządzania Parkiem Jurajskim używając Node.js i CommonJS:
jurassic-park-backend/
├── config/
│ ├── database.js # Konfiguracja bazy danych
│ ├── environment.js # Zmienne środowiskowe
│ └── security.js # Ustawienia bezpieczeństwa
├── models/
│ ├── dinosaur.js # Model dinozaura
│ ├── employee.js # Model pracownika
│ ├── facility.js # Model placówki
│ └── index.js # Agregator modeli
├── controllers/
│ ├── dinosaurController.js # Kontroler dinozaurów
│ ├── securityController.js # Kontroler bezpieczeństwa
│ └── employeeController.js # Kontroler pracowników
├── routes/
│ ├── api.js # Główny router API
│ ├── dinosaurs.js # Trasy związane z dinozaurami
│ └── security.js # Trasy związane z bezpieczeństwem
├── services/
│ ├── monitoringService.js # Usługa monitorowania
│ ├── notificationService.js # Usługa powiadomień
│ └── loggingService.js # Usługa logowania
├── utils/
│ ├── logger.js # Narzędzie do logowania
│ └── validators.js # Walidatory danych
├── middleware/
│ ├── auth.js # Middleware autentykacji
│ └── errorHandler.js # Obsługa błędów
├── app.js # Główna aplikacja
└── server.js # Plik startowy serweraZobaczmy, jak wyglądałyby przykładowe implementacje tych modułów:
Plik konfiguracyjny (config/database.js)
// config/database.js
module.exports = {
host: process.env.DB_HOST || 'localhost',
port: process.env.DB_PORT || 27017,
name: process.env.DB_NAME || 'jurassic_park',
user: process.env.DB_USER || 'admin',
password: process.env.DB_PASSWORD || 'secret',
// Funkcja pomocnicza do tworzenia URI połączenia
getConnectionString: function() {
return `mongodb://${this.user}:${this.password}@${this.host}:${this.port}/${this.name}`;
}
};Model (models/dinosaur.js)
// models/dinosaur.js
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
// Schemat dinozaura
const dinosaurSchema = new Schema({
name: { type: String, required: true },
species: { type: String, required: true },
diet: { type: String, enum: ['carnivore', 'herbivore', 'omnivore'], required: true },
dangerLevel: { type: Number, min: 1, max: 10, required: true },
enclosureId: { type: Schema.Types.ObjectId, ref: 'Enclosure' },
health: { type: Number, default: 100 },
status: {
isContained: { type: Boolean, default: true },
lastCheck: { type: Date, default: Date.now }
},
createdAt: { type: Date, default: Date.now },
updatedAt: { type: Date, default: Date.now }
});
// Metody schematu
dinosaurSchema.methods.feed = function() {
this.health = Math.min(100, this.health + 20);
this.updatedAt = Date.now();
return this.save();
};
dinosaurSchema.methods.checkStatus = function() {
return {
name: this.name,
health: this.health,
isContained: this.status.isContained,
warning: this.dangerLevel > 7 ? "WYSOKI POZIOM ZAGROŻENIA" : ""
};
};
// Metody statyczne
dinosaurSchema.statics.findDangerous = function() {
return this.find({ dangerLevel: { $gte: 8 } });
};
// Pre-save hook
dinosaurSchema.pre('save', function(next) {
this.updatedAt = Date.now();
next();
});
// Utworzenie modelu
const Dinosaur = mongoose.model('Dinosaur', dinosaurSchema);
// Eksport modelu
module.exports = Dinosaur;Kontroler (controllers/dinosaurController.js)
// controllers/dinosaurController.js
const Dinosaur = require('../models/dinosaur');
const logger = require('../utils/logger');
// Obiekt kontrolera z wieloma metodami
const dinosaurController = {
// Pobierz wszystkie dinozaury
getAllDinosaurs: async (req, res) => {
try {
const dinosaurs = await Dinosaur.find().populate('enclosureId');
res.json(dinosaurs);
} catch (error) {
logger.error('Błąd podczas pobierania dinozaurów:', error);
res.status(500).json({ error: 'Błąd serwera' });
}
},
// Pobierz dinozaura po ID
getDinosaurById: async (req, res) => {
try {
const dinosaur = await Dinosaur.findById(req.params.id).populate('enclosureId');
if (!dinosaur) {
return res.status(404).json({ error: 'Dinozaur nie znaleziony' });
}
res.json(dinosaur);
} catch (error) {
logger.error(`Błąd podczas pobierania dinozaura ID=${req.params.id}: `, error);
res.status(500).json({ error: 'Błąd serwera' });
}
},
// Dodaj nowego dinozaura
createDinosaur: async (req, res) => {
try {
const { name, species, diet, dangerLevel, enclosureId } = req.body;
const newDinosaur = new Dinosaur({
name,
species,
diet,
dangerLevel,
enclosureId
});
await newDinosaur.save();
logger.info(`Dodano nowego dinozaura: ${name} (${species})`);
res.status(201).json(newDinosaur);
} catch (error) {
logger.error('Błąd podczas tworzenia dinozaura:', error);
res.status(400).json({ error: error.message });
}
},
// Nakarm dinozaura
feedDinosaur: async (req, res) => {
try {
const dinosaur = await Dinosaur.findById(req.params.id);
if (!dinosaur) {
return res.status(404).json({ error: 'Dinozaur nie znaleziony' });
}
await dinosaur.feed();
logger.info(`Nakarmiono dinozaura: ${dinosaur.name}`);
res.json({
message: `${dinosaur.name} został nakarmiony. Poziom zdrowia: ${dinosaur.health}%`,
health: dinosaur.health
});
} catch (error) {
logger.error(`Błąd podczas karmienia dinozaura ID=${req.params.id}: `, error);
res.status(500).json({ error: 'Błąd serwera' });
}
},
// Znajdź niebezpieczne dinozaury
getDangerousDinosaurs: async (req, res) => {
try {
const dangerousDinos = await Dinosaur.findDangerous();
res.json(dangerousDinos);
} catch (error) {
logger.error('Błąd podczas pobierania niebezpiecznych dinozaurów:', error);
res.status(500).json({ error: 'Błąd serwera' });
}
}
};
// Eksport całego obiektu kontrolera
module.exports = dinosaurController;Trasy (routes/dinosaurs.js)
// routes/dinosaurs.js
const express = require('express');
const router = express.Router();
const dinosaurController = require('../controllers/dinosaurController');
const authMiddleware = require('../middleware/auth');
// Trasy związane z dinozaurami
router.get('/', dinosaurController.getAllDinosaurs);
router.get('/dangerous', dinosaurController.getDangerousDinosaurs);
router.get('/:id', dinosaurController.getDinosaurById);
// Trasy wymagające uwierzytelnienia
router.post('/', authMiddleware.verifyToken, dinosaurController.createDinosaur);
router.post('/:id/feed', authMiddleware.verifyToken, dinosaurController.feedDinosaur);
// Eksport routera
module.exports = router;Główny plik aplikacji (app.js)
// app.js
const express = require('express');
const mongoose = require('mongoose');
const cors = require('cors');
const morgan = require('morgan');
const helmet = require('helmet');
// Importy konfiguracji i middleware
const dbConfig = require('./config/database');
const errorHandler = require('./middleware/errorHandler');
const logger = require('./utils/logger');
// Importy tras
const apiRouter = require('./routes/api');
const dinosaurRoutes = require('./routes/dinosaurs');
const securityRoutes = require('./routes/security');
// Inicjalizacja aplikacji Express
const app = express();
// Middleware
app.use(helmet()); // Bezpieczeństwo
app.use(cors()); // Obsługa Cross-Origin Resource Sharing
app.use(morgan('dev')); // Logowanie żądań HTTP
app.use(express.json()); // Parsowanie JSON
app.use(express.urlencoded({ extended: false })); // Parsowanie formularzy
// Połączenie z bazą danych
mongoose.connect(dbConfig.getConnectionString(), {
useNewUrlParser: true,
useUnifiedTopology: true
})
.then(() => {
logger.info('Połączono z bazą danych MongoDB');
})
.catch(err => {
logger.error('Błąd połączenia z bazą danych:', err);
process.exit(1);
});
// Trasy
app.use('/api', apiRouter);
app.use('/api/dinosaurs', dinosaurRoutes);
app.use('/api/security', securityRoutes);
// Obsługa błędów 404
app.use((req, res, next) => {
res.status(404).json({ error: 'Nie znaleziono' });
});
// Centralna obsługa błędów
app.use(errorHandler);
// Eksport aplikacji
module.exports = app;Plik startowy serwera (server.js)
// server.js
const http = require('http');
const app = require('./app');
const logger = require('./utils/logger');
// Ustawienia portu
const port = process.env.PORT || 3000;
app.set('port', port);
// Utworzenie serwera HTTP
const server = http.createServer(app);
// Nasłuchiwanie na połączenia
server.listen(port, () => {
logger.info(`Serwer Parku Jurajskiego uruchomiony na porcie ${port}`);
});
// Obsługa błędów serwera
server.on('error', (error) => {
if (error.syscall !== 'listen') {
throw error;
}
logger.error(`Błąd serwera: ${error}`);
process.exit(1);
});Circular Dependencies (Zależności cykliczne)
Jednym z wyzwań przy pracy z CommonJS (i modułami ogólnie) są zależności cykliczne, które występują, gdy moduł A importuje moduł B, a moduł B importuje moduł A:
// dinosaurUtils.js
const Dinosaur = require('./dinosaur');
function isDangerous(dino) {
return dino.dangerLevel > 7;
}
module.exports = { isDangerous };
// dinosaur.js
const dinosaurUtils = require('./dinosaurUtils'); // Zależność cykliczna!
class Dinosaur {
// ... implementacja klasy
isHighRisk() {
return dinosaurUtils.isDangerous(this);
}
}
module.exports = Dinosaur;CommonJS radzi sobie z zależnościami cyklicznymi, ale może to prowadzić do dziwnych zachowań, jak niekompletne obiekty. Aby uniknąć takich problemów:
- Przekształć strukturę kodu, aby uniknąć zależności cyklicznych
- Użyj wzorca dependency injection
- Przenieś współdzielony kod do trzeciego modułu, z którego importują oba
Transpilacja CommonJS do ES Modules i odwrotnie
W wielu projektach musimy obsługiwać zarówno CommonJS, jak i ES Modules. Na przykład frontend naszego Parku Jurajskiego może używać ES Modules, a backend CommonJS. Co zrobić, gdy chcemy współdzielić kod?
Babel do transpilacji
Możemy użyć Babel do transpilacji między formatami:
// babel.config.js dla ES Modules -> CommonJS
module.exports = {
presets: [
['@babel/preset-env', {
targets: {
node: 'current'
},
modules: 'commonjs' // Konwertuj import/export na require/exports
}]
]
};Dual Package Hazard
Innym podejściem jest tworzenie pakietów obsługujących oba formaty modułów. W package.json możesz zdefiniować:
{
"name": "jurassic-park-utils",
"version": "1.0.0",
"main": "dist/index.js", // CommonJS entry
"module": "dist/index.mjs", // ES Module entry
"exports": {
"import": "./dist/index.mjs",
"require": "./dist/index.js"
}
}Nowoczesne podejście: Node.js z ES Modules
Nowsze wersje Node.js (od 13.2.0) oficjalnie wspierają ES Modules. Możemy włączyć to wsparcie na kilka sposobów:
- Używając rozszerzenia
.mjsdla plików z ES Modules - Ustawiając
"type": "module"w package.json
Jednak wiele pakietów npm nadal używa CommonJS, więc prawdopodobnie będziesz musiał pracować z oboma systemami.
Praktyczny przykład: Migracja z CommonJS do ES Modules
Załóżmy, że chcemy zmigrować część naszego backendu z CommonJS do ES Modules. Oto jak mogłaby wyglądać taka migracja:
Oryginalna wersja CommonJS (dinosaurController.js)
// controllers/dinosaurController.js (CommonJS)
const Dinosaur = require('../models/dinosaur');
const logger = require('../utils/logger');
function getAllDinosaurs(req, res) {
// implementacja
}
function getDinosaurById(req, res) {
// implementacja
}
module.exports = {
getAllDinosaurs,
getDinosaurById
};Migracja do ES Modules (dinosaurController.mjs)
// controllers/dinosaurController.mjs (ES Modules)
import Dinosaur from '../models/dinosaur.mjs';
import logger from '../utils/logger.mjs';
export function getAllDinosaurs(req, res) {
// implementacja
}
export function getDinosaurById(req, res) {
// implementacja
}
// Możemy też eksportować domyślnie obiekt z funkcjami
export default {
getAllDinosaurs,
getDinosaurById
};Wrapper do kompatybilności
Czasami potrzebujemy utworzyć wrapper, który pozwoli na import modułu ES Module z kodu CommonJS:
// controllers/dinosaurControllerWrapper.js (CommonJS)
// Ten plik ładuje moduł ES Module i eksportuje go jako CommonJS
const importESM = async () => {
const controller = await import('./dinosaurController.mjs');
return controller.default; // lub wybrane funkcje
};
// Eksportujemy funkcję, która zwraca Promise z kontrolerem
module.exports = importESM();Podsumowanie
CommonJS to powszechnie używany system modułów w Node.js, który pozwala na organizację kodu w odrębne moduły, co jest kluczowe dla budowania skalowalnych aplikacji, takich jak backend naszego systemu zarządzania Parkiem Jurajskim.
Główne koncepcje CommonJS to:
- Funkcja
require()do importowania modułów - Obiekt
module.exportslubexportsdo eksportowania elementów - Synchroniczne ładowanie modułów
- Niezbędne buforowanie modułów dla wydajności
Mimo rosnącej popularności ES Modules, CommonJS pozostaje istotnym systemem modułów, szczególnie w ekosystemie Node.js. Zrozumienie różnic między CommonJS a ES Modules jest kluczowe dla efektywnego rozwoju aplikacji JavaScript, które mogą działać zarówno w przeglądarce, jak i na serwerze.
W naszym Parku Jurajskim używamy CommonJS dla backendu (monitoring, baza danych, kontrola bezpieczeństwa) i ES Modules dla frontendu (interfejs użytkownika, dashboardy, powiadomienia). Ta kombinacja zapewnia nam najlepsze z obu światów i pozwala efektywnie zarządzać systemem, który musi być niezawodny - w końcu bezpieczeństwo parku i jego gości zależy od naszego kodu!
W następnym ćwiczeniu przyjrzymy się dynamicznemu importowaniu modułów, które pozwala na jeszcze większą elastyczność w ładowaniu kodu na żądanie, co może być kluczowe w sytuacjach awaryjnych w Parku Jurajskim.
Kod do tej lekcji: main.js
// CommonJS w Parku Jurajskim - Backend Node.js
// Demonstracja systemu require/module.exports
console.log("Backend Parku Jurajskiego - CommonJS");
console.log("System zarządzania serwerem Node.js\n");
// ===========================================
// Symulacja modułów CommonJS
// ===========================================
// === dinosaur.js - Model dinozaura (CommonJS) ===
class Dinosaur {
constructor(name, species, diet, dangerLevel) {
this.name = name;
this.species = species;
this.diet = diet;
this.dangerLevel = dangerLevel;
this.health = 100;
this.id = `DINO-${Math.random().toString(36).substr(2, 9).toUpperCase()}`;
}
feed() {
this.health = Math.min(100, this.health + 20);
return { success: true, message: `${this.name} nakarmiony`, health: this.health };
}
getDetails() {
return {
id: this.id,
name: this.name,
species: this.species,
diet: this.diet,
dangerLevel: this.dangerLevel,
health: this.health
};
}
}
// CommonJS export - główna klasa
const DinosaurModule = Dinosaur;
// === database.js - Symulacja bazy danych (CommonJS) ===
const database = {
dinosaurs: new Map(),
enclosures: new Map(),
logs: []
};
function saveDinosaur(dinosaur) {
database.dinosaurs.set(dinosaur.id, dinosaur);
database.logs.push({ action: 'SAVE_DINOSAUR', id: dinosaur.id, timestamp: Date.now() });
return { success: true, id: dinosaur.id };
}
function getDinosaur(id) {
const dino = database.dinosaurs.get(id);
return dino || null;
}
function getAllDinosaurs() {
return Array.from(database.dinosaurs.values());
}
function deleteDinosaur(id) {
const deleted = database.dinosaurs.delete(id);
if (deleted) {
database.logs.push({ action: 'DELETE_DINOSAUR', id, timestamp: Date.now() });
}
return { success: deleted };
}
function getDatabaseStats() {
return {
dinosaurCount: database.dinosaurs.size,
enclosureCount: database.enclosures.size,
totalLogs: database.logs.length
};
}
// CommonJS multiple exports
const DatabaseModule = {
saveDinosaur,
getDinosaur,
getAllDinosaurs,
deleteDinosaur,
getDatabaseStats
};
// === config.js - Konfiguracja (CommonJS) ===
const config = {
server: {
port: 3000,
host: 'localhost',
environment: 'development'
},
database: {
url: 'mongodb://localhost:27017/jurassic-park',
maxConnections: 10
},
security: {
maxDangerLevel: 10,
alertThreshold: 7
},
park: {
maxDinosaurs: 50,
maxVisitors: 1000,
openingHours: { start: 9, end: 18 }
}
};
// CommonJS config export
const ConfigModule = config;
// === logger.js - System logowania (CommonJS) ===
const LOG_LEVELS = {
INFO: 'INFO',
WARN: 'WARN',
ERROR: 'ERROR',
DEBUG: 'DEBUG'
};
function formatLogMessage(level, message) {
const timestamp = new Date().toISOString();
return `[${timestamp}] [${level}] ${message}`;
}
function log(level, message) {
const formatted = formatLogMessage(level, message);
console.log(formatted);
database.logs.push({ level, message, timestamp: Date.now() });
}
function info(message) { log(LOG_LEVELS.INFO, message); }
function warn(message) { log(LOG_LEVELS.WARN, message); }
function error(message) { log(LOG_LEVELS.ERROR, message); }
function debug(message) { log(LOG_LEVELS.DEBUG, message); }
// CommonJS logger exports
const LoggerModule = {
LOG_LEVELS,
log,
info,
warn,
error,
debug
};
// === api-routes.js - API endpoints (CommonJS) ===
class DinosaurAPI {
static createDinosaur(req) {
const { name, species, diet, dangerLevel } = req.body;
LoggerModule.info(`Creating dinosaur: ${name}`);
const dinosaur = new DinosaurModule(name, species, diet, dangerLevel);
DatabaseModule.saveDinosaur(dinosaur);
LoggerModule.info(`Dinosaur created: ${dinosaur.id}`);
return {
status: 201,
data: dinosaur.getDetails()
};
}
static getDinosaur(req) {
const { id } = req.params;
LoggerModule.debug(`Fetching dinosaur: ${id}`);
const dinosaur = DatabaseModule.getDinosaur(id);
if (!dinosaur) {
LoggerModule.warn(`Dinosaur not found: ${id}`);
return {
status: 404,
error: 'Dinosaur not found'
};
}
return {
status: 200,
data: dinosaur.getDetails()
};
}
static listDinosaurs() {
LoggerModule.debug('Listing all dinosaurs');
const dinosaurs = DatabaseModule.getAllDinosaurs();
return {
status: 200,
data: dinosaurs.map(d => d.getDetails()),
count: dinosaurs.length
};
}
static deleteDinosaur(req) {
const { id } = req.params;
LoggerModule.info(`Deleting dinosaur: ${id}`);
const result = DatabaseModule.deleteDinosaur(id);
if (!result.success) {
return {
status: 404,
error: 'Dinosaur not found'
};
}
LoggerModule.info(`Dinosaur deleted: ${id}`);
return {
status: 200,
data: { deleted: true }
};
}
static getServerStats() {
LoggerModule.debug('Fetching server stats');
const dbStats = DatabaseModule.getDatabaseStats();
return {
status: 200,
data: {
...dbStats,
config: {
maxDinosaurs: ConfigModule.park.maxDinosaurs,
environment: ConfigModule.server.environment
}
}
};
}
}
// CommonJS API export
const APIModule = DinosaurAPI;
// ===========================================
// DEMONSTRACJA SYSTEMU COMMONJS
// ===========================================
console.log("=== INICJALIZACJA SERWERA ===\n");
LoggerModule.info('Server starting...');
LoggerModule.info(`Port: ${ConfigModule.server.port}`);
LoggerModule.info(`Environment: ${ConfigModule.server.environment}`);
console.log("\n=== TWORZENIE DINOZAURÓW (API CALLS) ===\n");
// Symulacja requestów API
const req1 = {
body: { name: 'Rexy', species: 'T-Rex', diet: 'carnivore', dangerLevel: 9 }
};
const response1 = APIModule.createDinosaur(req1);
console.log('POST /api/dinosaurs:', JSON.stringify(response1, null, 2));
const req2 = {
body: { name: 'Blue', species: 'Velociraptor', diet: 'carnivore', dangerLevel: 7 }
};
const response2 = APIModule.createDinosaur(req2);
console.log('\nPOST /api/dinosaurs:', JSON.stringify(response2, null, 2));
const req3 = {
body: { name: 'Gentle Giant', species: 'Brachiosaurus', diet: 'herbivore', dangerLevel: 2 }
};
const response3 = APIModule.createDinosaur(req3);
console.log('\nPOST /api/dinosaurs:', JSON.stringify(response3, null, 2));
console.log("\n=== POBIERANIE DANYCH (API CALLS) ===\n");
// Lista wszystkich dinozaurów
const listResponse = APIModule.listDinosaurs();
console.log('GET /api/dinosaurs:', JSON.stringify(listResponse, null, 2));
console.log("\n=== STATYSTYKI SERWERA ===\n");
const statsResponse = APIModule.getServerStats();
console.log('GET /api/stats:', JSON.stringify(statsResponse, null, 2));
console.log("\n=== RÓŻNICE: CommonJS vs ES Modules ===\n");
console.log("CommonJS (Node.js):");
console.log(" - Używa: require() i module.exports");
console.log(" - Synchroniczne ładowanie");
console.log(" - Dynamiczne importy w runtime");
console.log(" - Wartość jest kopiowana\n");
console.log("ES Modules (ES6+):");
console.log(" - Używa: import i export");
console.log(" - Asynchroniczne ładowanie");
console.log(" - Statyczne importy w compile-time");
console.log(" - Wartość jest referencją (live binding)\n");
console.log("Przykład CommonJS:");
console.log(" // dinosaur.js");
console.log(" module.exports = class Dinosaur { ... };");
console.log("");
console.log(" // main.js");
console.log(" const Dinosaur = require('./dinosaur');\n");
console.log("Przykład ES Modules:");
console.log(" // dinosaur.js");
console.log(" export default class Dinosaur { ... }");
console.log("");
console.log(" // main.js");
console.log(" import Dinosaur from './dinosaur.js';\n");
LoggerModule.info('Demo completed successfully!');
console.log("\nBackend Parku Jurajskiego gotowy!");Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Zadania praktyczne w grze
- Układanie w poziomie
Ułóż elementy eksportu funkcji: