Kapitel 3: Globale Objekte & Core-Module

🎯 Lernziele

In diesem Kapitel lernen Sie:

✅ Globale Objekte in Node.js (global, console, process)
✅ Unterschied zu Browser (window vs global)
✅ Core-Module kennenlernen (vorinstalliert)
✅ fs-Modul (Dateisystem-Operationen)
✅ path-Modul (Pfadverarbeitung)
✅ url-Modul (URL-Analyse)
✅ http-Modul (HTTP-Server erstellen)
✅ Module importieren (require()) und exportieren (module.exports)

3.1 Globale Objekte

🌍 Das `global`-Objekt

In Node.js ist global das globale Objekt (ähnlich wie window im Browser).

javascript

// Zugriff auf globale Objekte
console.log(global === globalThis); // true

// Eigene globale Variable (⚠️ Nicht empfohlen!)
global.meineVariable = 'Hallo';
console.log(meineVariable); // 'Hallo'

📊 Vergleich: Browser vs. Node.js

Browser	Node.js	Beschreibung
`window`	`global`	Globales Objekt
`document`	❌ Nicht vorhanden	DOM (nur Browser)
`alert()`	❌ Nicht vorhanden	Dialog (nur Browser)
`console`	`console`	Konsolenausgabe
`setTimeout()`	`setTimeout()`	Timer-Funktionen
`process`	`process`	Prozessinformationen

🖥️ Das `console`-Objekt (erweitert)

javascript

// Verschiedene Ausgabemethoden
console.log('Normale Nachricht');
console.error('Fehlermeldung');     // Rot
console.warn('Warnung');            // Gelb
console.info('Information');         // Info-Symbol
console.debug('Debug-Nachricht');   // Debug-Level

// Zeitmessung
console.time('MeinTimer');
// ... Code ausführen ...
console.timeEnd('MeinTimer');      // Zeigt Zeit in ms

// Gruppierung
console.group('Gruppe 1');
console.log('Nachricht 1');
console.log('Nachricht 2');
console.groupEnd();

⚙️ Das `process`-Objekt

Das process-Objekt enthält Informationen über den aktuellen Node.js-Prozess.

javascript

// Node.js Version
console.log(process.version);        // z.B. 'v20.11.0'

// Platform (Betriebssystem)
console.log(process.platform);        // 'win32', 'darwin', 'linux'

// Arbeitsspeicher-Nutzung
console.log(process.memoryUsage());

// Kommandozeilen-Argumente
console.log(process.argv);          
// Beispiel: node script.js arg1 arg2
// → ['node', 'script.js', 'arg1', 'arg2']

// Prozess beenden
process.exit(0);                   // 0 = Erfolg, 1 = Fehler

Praktisches Beispiel: Kommandozeilen-Argumente

javascript

// args.js
const args = process.argv.slice(2);  // Erste 2 Elemente ignorieren
console.log('Übergebene Argumente:', args);

// Aufruf: node args.js Hallo Welt
// Ausgabe: Übergebene Argumente: [ 'Hallo', 'Welt' ]

3.2 Core-Module

Core-Module sind in Node.js eingebaute Module, die ohne Installation sofort verwendet werden können.

📦 Wichtige Core-Module

Modul	Beschreibung	Verwendung
`fs`	Dateisystem	Dateien lesen/schreiben
`path`	Pfadverarbeitung	Pfade plattformübergreifend bearbeiten
`url`	URL-Analyse	URLs parsen und manipulieren
`http`	HTTP-Server	HTTP-Server und Client erstellen
`os`	Betriebssystem	Systeminformationen abrufen
`events`	Event-Emitter	Event-gesteuerte Programmierung
`util`	Hilfsfunktionen	Nützliche Utility-Funktionen

📥 Modul importieren

javascript

// Core-Modul importieren
const fs = require('fs');
const path = require('path');
const http = require('http');

// Verwendung
const daten = fs.readFileSync('datei.txt', 'utf8');
console.log(daten);

3.3 Core-Module in der Praxis

📁 `fs`-Modul (Dateisystem)

Das fs-Modul bietet Funktionen zur Interaktion mit dem Dateisystem.

Asynchrone vs. Synchrone Methoden

javascript

const fs = require('fs');

// ❌ Synchrone Methode (blockierend) - Nicht empfohlen für Produktion!
try {
  const daten = fs.readFileSync('datei.txt', 'utf8');
  console.log('Gelesen:', daten);
} catch (err) {
  console.error('Fehler:', err);
}

// ✅ Asynchrone Methode (nicht-blockierend) - Empfohlen!
fs.readFile('datei.txt', 'utf8', (err, daten) => {
  if (err) {
    console.error('Fehler:', err);
    return;
  }
  console.log('Gelesen:', daten);
});
console.log('Dies wird zuerst ausgegeben!');

Datei schreiben

javascript

const fs = require('fs');

// Asynchron schreiben
const inhalt = 'Hallo Node.js!\n';
fs.writeFile('ausgabe.txt', inhalt, 'utf8', (err) => {
  if (err) {
    console.error('Fehler beim Schreiben:', err);
    return;
  }
  console.log('Datei wurde geschrieben!');
});

// Datei anhängen (append)
fs.appendFile('ausgabe.txt', 'Neue Zeile\n', 'utf8', (err) => {
  if (err) throw err;
  console.log('Zeile wurde angehängt!');
});

Datei/Directory existenz prüfen

javascript

const fs = require('fs');

// Datei existiert?
fs.access('datei.txt', fs.constants.F_OK, (err) => {
  if (err) {
    console.log('Datei existiert nicht');
    return;
  }
  console.log('Datei existiert');
});

// Oder mit fs.existsSync() (synchron)
if (fs.existsSync('datei.txt')) {
  console.log('Datei existiert');
}

Verzeichnis erstellen/löschen

javascript

const fs = require('fs');

// Verzeichnis erstellen
fs.mkdir('mein-ordner', { recursive: true }, (err) => {
  if (err) throw err;
  console.log('Ordner erstellt!');
});

// Verzeichnis löschen
fs.rmdir('mein-ordner', { recursive: true }, (err) => {
  if (err) throw err;
  console.log('Ordner gelöscht!');
});

🗂️ `path`-Modul (Pfadverarbeitung)

Das path-Modul hilft bei der plattformübergreifenden Verarbeitung von Dateipfaden.

javascript

const path = require('path');

// Pfad zusammenfügen (plattformübergreifend)
const vollständigerPfad = path.join(__dirname, 'daten', 'datei.txt');
console.log(vollständigerPfad);
// Windows: C:\projekt\daten\datei.txt
// macOS/Linux: /home/user/projekt/daten/datei.txt

// Pfad auflösen (vereinfachen)
console.log(path.resolve('daten/../datei.txt')); 
// → Absoluter Pfad

// Dateinamen extrahieren
console.log(path.basename('/pfad/zu/datei.txt')); // 'datei.txt'
console.log(path.extname('/pfad/zu/datei.txt'));  // '.txt'

// Verzeichnisname extrahieren
console.log(path.dirname('/pfad/zu/datei.txt'));  // '/pfad/zu'

// __dirname und __filename (spezielle Variablen)
console.log('Aktuelles Verzeichnis:', __dirname);
console.log('Aktuelle Datei:', __filename);

Praktisches Beispiel: Pfad-Sicherheit

javascript

const path = require('path');

// ❌ Unsicher (Path Traversal Angriff möglich)
const unsicher = '/daten/' + userEingabe;

// ✅ Sicher
const sicher = path.join('/daten', path.basename(userEingabe));

🔗 `url`-Modul (URL-Analyse)

javascript

const url = require('url');

const urlString = 'https://example.com:8080/pfad/zu/ressource?name=Max&alter=25#abschnitt';

// URL parsen (Legacy-API)
const parsedUrl = url.parse(urlString, true);
console.log(parsedUrl.protocol);   // 'https:'
console.log(parsedUrl.host);       // 'example.com:8080'
console.log(parsedUrl.pathname);   // '/pfad/zu/ressource'
console.log(parsedUrl.query);      // { name: 'Max', alter: '25' }
console.log(parsedUrl.hash);       // '#abschnitt'

// ✅ Moderne API (empfohlen)
const neueUrl = new URL(urlString);
console.log(neueUrl.hostname);    // 'example.com'
console.log(neueUrl.port);        // '8080'
console.log(neueUrl.searchParams.get('name')); // 'Max'

🌐 `http`-Modul (HTTP-Server)

Das http-Modul ermöglicht das Erstellen von HTTP-Servern.

Einfacher HTTP-Server

javascript

const http = require('http');

// Server erstellen
const server = http.createServer((req, res) => {
  // req: Anfrage-Objekt (Request)
  // res: Antwort-Objekt (Response)
  
  // HTTP-Header setzen
  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
  
  // Antwort senden
  res.end('Hallo von Node.js Server!');
});

// Server auf Port 3000 starten
server.listen(3000, () => {
  console.log('🚀 Server läuft auf http://localhost:3000');
});

Server mit Routing

javascript

const http = require('http');

const server = http.createServer((req, res) => {
  const url = req.url;
  
  if (url === '/') {
    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
    res.end('<h1>Willkommen!</h1>');
  } else if (url === '/about') {
    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
    res.end('<h1>Über uns</h1>');
  } else {
    res.writeHead(404, { 'Content-Type': 'text/html; charset=utf-8' });
    res.end('<h1>404 - Seite nicht gefunden</h1>');
  }
});

server.listen(3000, () => {
  console.log('Server läuft auf Port 3000');
});

3.4 Module importieren/exportieren

📥 Module importieren mit `require()`

javascript

// Core-Modul importieren
const fs = require('fs');

// Drittanbieter-Paket importieren (aus node_modules)
const express = require('express');

// Eigenes Modul importieren
const meinModul = require('./mein-modul');

📤 Module exportieren mit `module.exports`

javascript

// mein-modul.js

// Einzelne Funktion exportieren
function gruesse(name) {
  return `Hallo ${name}!`;
}
module.exports = gruesse;

// Oder: Objekt mit mehreren Funktionen exportieren
module.exports = {
  gruesse: (name) => `Hallo ${name}!`,
  addiere: (a, b) => a + b,
  subtrahiere: (a, b) => a - b
};

📝 Verwendung

javascript

// app.js
const meinModul = require('./mein-modul');

// Falls einzelne Funktion exportiert wurde
console.log(meinModul('Max'));

// Falls Objekt exportiert wurde
console.log(meinModul.gruesse('Max'));
console.log(meinModul.addiere(5, 3));

3.5 Praxisbeispiel: Lokale Dateien lesen, einfachen Server erstellen

📂 Fallstudie 1: Datei lesen und anzeigen

javascript

// datei-leser.js
const fs = require('fs');
const http = require('http');

const server = http.createServer((req, res) => {
  if (req.url === '/') {
    // Datei lesen
    fs.readFile('index.html', 'utf8', (err, daten) => {
      if (err) {
        res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
        res.end('Fehler beim Lesen der Datei');
        return;
      }
      
      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
      res.end(daten);
    });
  }
});

server.listen(3000, () => {
  console.log('Server läuft auf http://localhost:3000');
});

🌐 Fallstudie 2: Einfacher API-Server

javascript

// api-server.js
const http = require('http');

// Beispiel-Daten
const nutzer = [
  { id: 1, name: 'Max', alter: 25 },
  { id: 2, name: 'Anna', alter: 30 }
];

const server = http.createServer((req, res) => {
  // CORS-Header setzen (für Browser-Zugriff)
  res.setHeader('Access-Control-Allow-Origin', '*');
  res.setHeader('Content-Type', 'application/json; charset=utf-8');
  
  if (req.url === '/api/nutzer') {
    res.writeHead(200);
    res.end(JSON.stringify(nutzer));
  } else {
    res.writeHead(404);
    res.end(JSON.stringify({ fehler: 'Route nicht gefunden' }));
  }
});

server.listen(3000, () => {
  console.log('API-Server läuft auf http://localhost:3000');
});

📝 Zusammenfassung

In diesem Kapitel haben Sie gelernt:

✅ Globale Objekte: global, console, process
✅ Core-Module: fs, path, url, http
✅ Dateioperationen (lesen, schreiben, anhängen)
✅ Pfadverarbeitung (plattformübergreifend)
✅ URL-Analyse und -manipulation
✅ Einfachen HTTP-Server erstellen
✅ Module importieren (require()) und exportieren (module.exports)

🎯 Nächste Schritte

Im nächsten Kapitel werden wir:

Modularisierung vertiefen (CommonJS vs. ES Modules)
Eigene Module erstellen
Modul-Suchmechanismus verstehen

📚 Weiterführende Ressourcen

🎉 Kapitel 3 abgeschlossen! Weiter zu Kapitel 4: Modularisierung

Kapitel 3: Globale Objekte & Core-Module ​

🎯 Lernziele ​

3.1 Globale Objekte ​

🌍 Das global-Objekt ​

📊 Vergleich: Browser vs. Node.js ​

🖥️ Das console-Objekt (erweitert) ​

⚙️ Das process-Objekt ​

Praktisches Beispiel: Kommandozeilen-Argumente ​

3.2 Core-Module ​

📦 Wichtige Core-Module ​

📥 Modul importieren ​

3.3 Core-Module in der Praxis ​

📁 fs-Modul (Dateisystem) ​

Asynchrone vs. Synchrone Methoden ​

Datei schreiben ​

Datei/Directory existenz prüfen ​

Verzeichnis erstellen/löschen ​

🗂️ path-Modul (Pfadverarbeitung) ​

Praktisches Beispiel: Pfad-Sicherheit ​

🔗 url-Modul (URL-Analyse) ​

🌐 http-Modul (HTTP-Server) ​

Einfacher HTTP-Server ​

Server mit Routing ​

3.4 Module importieren/exportieren ​

📥 Module importieren mit require() ​

📤 Module exportieren mit module.exports ​

📝 Verwendung ​

3.5 Praxisbeispiel: Lokale Dateien lesen, einfachen Server erstellen ​

📂 Fallstudie 1: Datei lesen und anzeigen ​

🌐 Fallstudie 2: Einfacher API-Server ​

📝 Zusammenfassung ​

🎯 Nächste Schritte ​

📚 Weiterführende Ressourcen ​

Kapitel 3: Globale Objekte & Core-Module

🎯 Lernziele

3.1 Globale Objekte

🌍 Das `global`-Objekt

📊 Vergleich: Browser vs. Node.js

🖥️ Das `console`-Objekt (erweitert)

⚙️ Das `process`-Objekt

Praktisches Beispiel: Kommandozeilen-Argumente

3.2 Core-Module

📦 Wichtige Core-Module

📥 Modul importieren

3.3 Core-Module in der Praxis

📁 `fs`-Modul (Dateisystem)

Asynchrone vs. Synchrone Methoden

Datei schreiben

Datei/Directory existenz prüfen

Verzeichnis erstellen/löschen

🗂️ `path`-Modul (Pfadverarbeitung)

Praktisches Beispiel: Pfad-Sicherheit

🔗 `url`-Modul (URL-Analyse)

🌐 `http`-Modul (HTTP-Server)

Einfacher HTTP-Server

Server mit Routing

3.4 Module importieren/exportieren

📥 Module importieren mit `require()`

📤 Module exportieren mit `module.exports`

📝 Verwendung

3.5 Praxisbeispiel: Lokale Dateien lesen, einfachen Server erstellen

📂 Fallstudie 1: Datei lesen und anzeigen

🌐 Fallstudie 2: Einfacher API-Server

📝 Zusammenfassung

🎯 Nächste Schritte

📚 Weiterführende Ressourcen