Erste Schritte
REPL & Skripte ausführen
Die REPL (Read-Eval-Print Loop) ist eine interaktive Shell zum Experimentieren mit Node.js-Code. node --watch für Auto-Neustart in der Entwicklung nutzen. ES-Module verlangen type:module in package.json oder die .mjs-Endung.
# start the REPL (interactive shell)
node
# run a script
node app.js
# run with ES modules (type: module in package.json)
node --input-type=module app.js
# execute inline code
node -e "console.log(process.version)"
# watch mode (auto-restart on change)
node --watch app.jsVersion & Runtime-Flags
node --version gibt die Laufzeitversion aus. --trace-warnings zeigt Stacktraces für Laufzeitwarnungen. NODE_OPTIONS ist eine einzige Env-Variable mit CLI-Flags — praktisch in Containern oder npm-Skripten. --inspect öffnet den Chrome-DevTools-Debugger.
# check version
node --version # v20.11.0
node -p "process.versions.v8"
# enable warning stack traces
node --trace-warnings app.js
# pass NODE_OPTIONS (max ~128KB string)
NODE_OPTIONS="--max-old-space-size=4096" node app.js
# inspect memory usage at runtime
node --inspect app.jspackage.json & Projektinitialisierung
npm init erzeugt package.json. Das Feld "type" entscheidet über das Standard-Modulsystem: "module" aktiviert ES-Modul-Syntax in .js-Dateien, "commonjs" (Standard) behält require/module.exports. "main" ist der Einstiegspunkt, wenn das Paket required wird.
# scaffold a project (answer prompts)
npm init
# non-interactive defaults
npm init -y
# "type" controls module system
# "commonjs" (default) -> require/module.exports
# "module" -> import/export
{
"name": "my-app",
"version": "1.0.0",
"type": "module",
"main": "index.js",
"scripts": { "start": "node index.js" }
}CommonJS vs. ES-Module
Node unterstützt zwei Modulsysteme. CommonJS (require/module.exports) ist synchron und der historische Standard. ES-Module (import/export) sind der moderne Standard. Die Dateiendung (.mjs/.cjs) oder das Feld "type" in package.json entscheidet, welcher Parser für .js-Dateien verwendet wird.
# CommonJS (.cjs or type:commonjs) ----
const fs = require('fs'); // import
module.exports = { greet: () => 'hi' }; // export
# ES Modules (.mjs or type:module) -------
import fs from 'fs'; // import
export function greet() { return 'hi'; } // named export
export default { greet }; // default export
# .mjs is always ESM, .cjs is always CJS
node file.mjs # forced ESM
node file.cjs # forced CJSGlobale Objekte
Node stellt Globals wie process, console, Buffer und Timer ohne Imports bereit. __dirname und __filename gibt es nur in CommonJS — in ES-Modulen stattdessen import.meta.url verwenden. global ist das Root-Scope-Objekt (wie window in Browsern).
# available everywhere, no import needed
global; // global namespace object
process; // env, argv, stdin/stdout
console; // log, error, warn, table
setTimeout; // schedule a callback
setInterval; // schedule repeating callback
Buffer; // binary data (Uint8Array)
queueMicrotask;// schedule microtask
structuredClone; // deep clone
# CommonJS-only globals (not in ESM)
__dirname; // current directory
__filename; // current file pathAusführbare Skripte (Shebang)
Eine Shebang-Zeile (#!/usr/bin/env node) lässt eine Datei als eigenständigen Befehl unter Unix laufen. Nach chmod +x direkt ./cli.js ausführen. Das Feld "bin" in package.json mappt einen Befehlsnamen auf ein Skript — von CLI-Tools genutzt, die auf npm veröffentlicht werden, damit die globale Installation den Befehl freilegt.
#!/usr/bin/env node
// cli.js - make a file directly runnable
const name = process.argv[2] || 'world';
console.log(`Hello, ${name}!`);
# make it executable (Unix) and run directly
chmod +x cli.js
./cli.js Alice # Hello, Alice!
# or wire it up in package.json
{
"bin": { "mycli": "./cli.js" }
}Modulsystem
CommonJS require & exports
require() lädt synchron ein CommonJS-Modul und gibt sein module.exports zurück. require löst relative Pfade (./, ../), Built-ins (fs) und node_modules auf. Beim Ersetzen des ganzen Exports immer module.exports zuweisen (nicht exports), weil exports anfangs nur ein Alias für module.exports ist.
// math.js
function add(a, b) { return a + b; }
const PI = 3.14;
// export via module.exports
module.exports = { add, PI };
// or: exports.add = add; exports.PI = PI;
// app.js
const math = require('./math'); // .js optional
console.log(math.add(1, 2)); // 3
console.log(math.PI); // 3.14
// destructuring
const { add } = require('./math');
console.log(add(5, 7)); // 12ES-Module import/export
ES-Module nutzen statisches import/export — Bindings sind live und gehoistet. Der Default-Export wird mit beliebigem Namen importiert (ohne geschweifte Klammern); benannte Exporte brauchen geschweifte Klammern mit passenden Namen. import * as erzeugt ein Namensraum-Objekt. ESM ist von Design async und der moderne Standard.
// math.mjs (or type:module)
export function add(a, b) { return a + b; }
export const PI = 3.14;
export default function square(x) { return x * x; }
// app.mjs
import square, { add, PI } from './math.mjs';
console.log(add(1, 2)); // 3
console.log(square(5)); // 25
// import all as namespace
import * as math from './math.mjs';
console.log(math.PI); // 3.14Dynamisches import()
import() ist ein dynamischer, asyncer Import, der in CJS und ESM funktioniert. Er gibt ein Promise zurück, das zum Modulnamensraum auflöst, und ermöglicht Lazy-Loading und bedingte Imports — ideal, um die Startzeit zu senken oder optionale Features zu laden. Auch für Code-Splitting auf Servern nutzen.
// dynamic import returns a Promise
async function loadPlugin(name) {
const mod = await import(`./plugins/${name}.mjs`);
return mod.default;
}
// lazy-load heavy modules on demand
if (needPdf) {
const { exportPdf } = await import('./pdf.mjs');
exportPdf(data);
}
// works in both CommonJS and ESM
import('./optional.mjs')
.then(mod => mod.run())
.catch(err => console.error('load failed', err));Eingebaute Module
Node liefert Dutzende eingebaute Module — kein npm install nötig. Die meisten exponieren Callback-APIs; viele bieten auch Promise-Varianten unter dem Pfad 'module/promises' (fs/promises, dns/promises, stream/promises). require('module') (ohne ./) löst zuerst Built-ins auf, dann node_modules.
// core modules - no install, just require/import
const fs = require('fs'); // file system
const path = require('path'); // path handling
const http = require('http'); // HTTP server/client
const os = require('os'); // OS info
const crypto = require('crypto'); // hashing/encryption
const { EventEmitter } = require('events');
const { Buffer } = require('buffer');
const stream = require('stream'); // streams
const net = require('net'); // TCP
const child_process = require('child_process');
// some are promise-based (Node 10+)
const fsp = require('fs/promises'); // async/await fsModul-Caching & zirkuläre Dependencies
require() cache-t Module nach aufgelöstem Pfad, derselbe Modulcode läuft also einmal und Exports werden wiederverwendet. Zirkuläre Dependencies funktionieren, aber das zuerst geladene Modul sieht ein unvollständiges (partielles) exports-Objekt des zweiten — das Design entsprechend anpassen. delete require.cache zum Hot-Reload in der Entwicklung.
// modules are cached after first load
// a.js
require('./b'); // b loads, sets module.exports
const b = require('./b'); // returns cached b (same object)
console.log(b === require('./b')); // true
// circular dependency: a -> b -> a
// a.js: const b = require('./b'); b.f();
// b.js: const a = require('./a'); // a is PARTIAL here!
// module.exports = { f: () => a.x };
// inspect the cache
console.log(require.cache); // map of loaded modules
delete require.cache[require.resolve('./b')]; // force reload__dirname & import.meta.url
__dirname und __filename sind CommonJS-only-Globals und liefern den aktuellen Ordner-/Dateipfad. ES-Module haben solche Globals nicht — sie aus import.meta.url über fileURLToPath ableiten. import.meta.url ist die file://-URL des aktuellen Moduls und der ESM-Ersatz für __filename.
// CommonJS - synchronous path globals
console.log(__dirname); // /app/src
console.log(__filename); // /app/src/index.js
// ES Modules - no __dirname, use import.meta
import { fileURLToPath } from 'url';
import { dirname, join } from 'path';
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
const dataPath = join(__dirname, 'data.json');
// import.meta also carries the module URL
console.log(import.meta.url); // file:///app/src/index.mjsnpm & pnpm
npm init & package.json
npm init scaffoldet eine package.json. -y überspringt die Prompts mit Defaults. npm set speichert Konfiguration in ~/.npmrc für künftige Inits. Scoped-Pakete (@org/name) sind nützlich für Organisationen und um Namenskollisionen in der Registry zu vermeiden.
# create package.json interactively
npm init
# accept all defaults
npm init -y
# pnpm equivalent
pnpm init
# set author/license globally
npm set init-author-name "Alice"
npm set init-license MIT
# scope packages with @username
npm init --scope=@myorgDependencies installieren
npm install (ohne Argumente) installiert alle gelisteten Deps. Mit einem Namen wird er zur package.json hinzugefügt. --save-dev legt ihn in devDependencies (Test-/Build-Tools, nicht ausgeliefert). ^ erlaubt Minor+Patch-Updates, ~ nur Patch. -g installiert CLI-Tools global.
# install everything in package.json
npm install # alias: npm i
pnpm install # alias: pnpm i
# add a runtime dependency -> dependencies
npm install express
pnpm add express
# add a dev-only dependency -> devDependencies
npm install --save-dev jest # npm i -D jest
pnpm add -D jest
# install a specific version
npm install [email protected]
npm install lodash@^4.17.0 # caret: 4.x
npm install lodash@~4.17.0 # tilde: 4.17.x
# global install (CLI tools)
npm install -g pm2
pnpm add -g pm2npm-Skripte
Skripte in package.json laufen über npm run <name>. start und test sind besonders (npm start / npm test). Pre-/Post-Hooks (pretest, postbuild) laufen automatisch. Mit -- Argumente an den zugrunde liegenden Befehl weiterreichen. pnpm erlaubt es, das Wort "run" bei eigenen Skripten wegzulassen.
// package.json
{
"scripts": {
"start": "node index.js",
"dev": "node --watch index.js",
"test": "jest",
"build": "tsc && vite build"
}
}
# run a script
npm run dev # npm run-script dev
pnpm dev # pnpm has no "run" requirement
# "start" and "test" have shortcuts
npm start
npm test
# pre/post hooks run automatically
// "pretest": "npm run lint",
// "postbuild": "npm run deploy"
# pass extra args with --
npm run build -- --mode productionnpx & pnpm dlx
npx führt ein Paket-Binary ohne globale Installation aus — es lädt herunter, führt aus und verwirft. Perfekt für Scaffolders (create-vite) und das Ausführen von Tools aus node_modules/.bin. --yes überspringt die Installationsbestätigung. pnpm dlx ist das pnpm-Pendant.
# run a one-off command without installing globally
npx create-vite my-app
npx cowsay "hello"
# pin a version
npx prettier@3 --write .
# pnpm equivalent
pnpm dlx create-vite my-app
# execute a local bin from node_modules
npx jest # runs ./node_modules/.bin/jest
# never prompt, always download latest
npx --yes create-react-app my-appVersionierung & Lockfiles
SemVer: MAJOR für Breaking Changes, MINOR für Features, PATCH für Fixes. ^ (Caret) ist npms Standard und erlaubt Minor+Patch-Updates; ~ (Tilde) nur Patch. Lockfiles (package-lock.json) frieren den gesamten Dependency-Baum ein für reproduzierbare Installationen — in CI npm ci für Tempo und Sicherheit nutzen.
# semantic versioning: MAJOR.MINOR.PATCH
# 1.4.2 -> 1:breaking 4:feature 2:fix
"^1.4.2" # >=1.4.2 <2.0.0 (caret, default)
"~1.4.2" # >=1.4.2 <1.5.0 (tilde)
"1.4.2" # exact 1.4.2
">=1.4.0 <2.0.0" # range
# lockfiles pin the installed tree
npm install # writes/updates package-lock.json
pnpm install # writes pnpm-lock.yaml
yarn install # writes yarn.lock
# install exactly as locked (CI)
npm ci # clean install from lockfile
# find outdated deps
npm outdated
npm update # update within ^ rangesVeröffentlichen & Lifecycle
npm publish lädt dein Paket in die Registry hoch. npm version erhöht die Version, erzeugt einen git-Tag und committet. Lifecycle-Hooks (prepublishOnly, postpublish) automatisieren Build/Test beim Release. Unpublish ist nur innerhalb von 72 Stunden erlaubt — für alte Versionen lieber npm deprecate.
# login once
npm login
# publish to the registry
npm publish
npm publish --access public # scoped default restricted
# bump version (updates package.json + tag + commit)
npm version patch # 1.0.0 -> 1.0.1
npm version minor # 1.0.0 -> 1.1.0
npm version major # 1.0.0 -> 2.0.0
# lifecycle scripts (in package.json)
// "prepublishOnly": "npm test && npm run build",
// "prepublish": "npm run build",
// "postpublish": "git push --tags"
# unpublish within 72h
npm unpublish [email protected]Dateisystem (fs)
Dateien lesen
fs bietet sync (readFileSync), callback (readFile) und promise (fs/promises readFile) APIs. Sync-Aufrufe blockieren die Event-Loop — auf Servern vermeiden. fs/promises ist die moderne Wahl für async/await. Ohne Encoding liefert readFile einen Buffer.
const fs = require('fs');
// synchronous (blocks the event loop)
const text = fs.readFileSync('data.txt', 'utf8');
const buf = fs.readFileSync('image.png'); // Buffer
// asynchronous with callback (error-first)
fs.readFile('data.txt', 'utf8', (err, data) => {
if (err) return console.error(err);
console.log(data);
});
// async with fs/promises (preferred)
const fsp = require('fs/promises');
async function read() {
const text = await fsp.readFile('data.txt', 'utf8');
return text;
}Dateien schreiben
writeFile ersetzt standardmäßig die ganze Datei. Die flag-Option ändert das Verhalten: 'a' hängt an, 'wx' scheitert (EEXIST), wenn die Datei bereits existiert — nützlich für atomares Dateianlegen. JSON sollte vor dem Schreiben stringifiziert werden. Sync-Schreibvorgänge blockieren; fs/promises bevorzugen.
const fs = require('fs');
const fsp = require('fs/promises');
// sync
fs.writeFileSync('out.txt', 'hello');
// async callback
fs.writeFile('log.txt', 'line1\n', err => {
if (err) throw err;
});
// promise
await fsp.writeFile('config.json', JSON.stringify(cfg, null, 2));
// flags: 'w' write (default), 'a' append, 'wx' fail if exists
await fsp.writeFile('new.txt', 'x', { flag: 'wx' }); // throws if existsVerzeichnisse
mkdir mit { recursive: true } imitiert mkdir -p. readdir listet Einträge; { withFileTypes: true } liefert Dirent-Objekte, deren isDirectory()/isFile() zusätzliche stat-Aufrufe sparen. fsp.rm mit recursive+force ersetzt rmdir für nicht-leere Verzeichnisse (Node 14+).
const fsp = require('fs/promises');
// create (recursive like mkdir -p)
await fsp.mkdir('a/b/c', { recursive: true });
// list entries
const entries = await fsp.readdir('.');
// ['app.js', 'data', 'package.json']
// list with type info
const detailed = await fsp.readdir('.', { withFileTypes: true });
detailed.forEach(e => console.log(e.name, e.isDirectory()));
// remove
await fsp.rmdir('empty'); // empty dir only
await fsp.rm('folder', { recursive: true, force: true }); // rm -rf
// sync versions exist too: mkdirSync, readdirSync, rmSyncDatei-Stats & Metadaten
stat() gibt ein Stats-Objekt mit size, mtime und Typ-Helfern zurück. fs.exists (veraltet) nicht verwenden; access() in try/catch für racet-freie Existenzprüfungen — direktes Öffnen der Datei ist aber sicherer. fsWatch emittiert change-Events, ist plattformübergreifend aber inkonsistent.
const fsp = require('fs/promises');
const stats = await fsp.stat('data.txt');
stats.isFile(); // true
stats.isDirectory(); // false
stats.size; // bytes
stats.mtime; // Date modified
stats.birthtime; // Date created
stats.mode; // permission bits
// check existence (avoid existsSync for races)
try {
await fsp.access('config.json');
console.log('exists');
} catch {
console.log('missing');
}
// watch for changes
const watcher = fs.watch('.');
watcher.on('change', (eventType, filename) => {});fs.promises-API
fs/promises (Node 10+) stellt Promise-Versionen aller fs-Methoden bereit, ideal für async/await. opendir() gibt einen async Iterator für speichereffizienten Verzeichnisdurchlauf zurück. Mit path.join kombinieren für portable Pfade. Alle Methoden werfen bei Fehlern — in try/catch einhüllen.
const fsp = require('fs/promises');
const path = require('path');
// full async/await file operations
async function loadConfig() {
const file = path.join(__dirname, 'config.json');
const raw = await fsp.readFile(file, 'utf8');
return JSON.parse(raw);
}
async function saveConfig(cfg) {
const file = path.join(__dirname, 'config.json');
await fsp.writeFile(file, JSON.stringify(cfg, null, 2));
}
// iterate directory tree
for await (const entry of await fsp.opendir('.')) {
console.log(entry.name);
}Anhängen, Umbenennen, Löschen
appendFile fügt am Ende hinzu (legt die Datei an, falls sie fehlt). rename ist atomar auf demselben Dateisystem und wird zum Verschieben genutzt. unlink löscht eine Datei. copyFile kopiert Inhalte; fsp.cp (Node 16+) behandelt Verzeichnisse rekursiv. truncate verkleinert eine Datei auf die angegebene Länge.
const fsp = require('fs/promises');
// append to a file (creates if missing)
await fsp.appendFile('log.txt', new Date() + ' started\n');
// atomic rename (also for moving)
await fsp.rename('old.txt', 'new.txt');
// move across dirs
await fsp.rename('a/x.txt', 'b/x.txt');
// delete a file
await fsp.unlink('temp.txt');
// copy
await fsp.copyFile('src.txt', 'dest.txt');
// or fsp.cp('src', 'dest', { recursive: true })
// truncate to a length
await fsp.truncate('data.bin', 1024);Pfadbehandlung
path.join & path.resolve
path.join verkettet Segmente mit dem plattformspezifischen Trennzeichen und normalisiert das Ergebnis. path.resolve erzeugt einen absoluten Pfad ab process.cwd(); ein absolutes Segment verwirft vorherige Segmente. Immer path.join statt String-Konkatenation, damit Pfade auf Windows und POSIX funktionieren.
const path = require('path');
// join segments with the OS separator
path.join('src', 'utils', 'file.js');
// 'src/utils/file.js' (Linux) or 'src\utils\file.js' (Windows)
// resolve to an ABSOLUTE path (from cwd)
path.resolve('src', 'file.js');
// '/current/dir/src/file.js'
// resolve with absolute segment resets
path.resolve('/a', 'b', '/c', 'd'); // '/c/d'
// normalize '..' and '.' segments
path.normalize('a/b/../c/./d'); // 'a/c/d'
// never hardcode '/' — use path.join for portabilitydirname, basename, extname
dirname liefert das Verzeichnis, basename den Dateinamen (optional ohne Endung) und extname die letzte Endung (inklusive Punkt). Bei mehrteiligen Endungen wie .tar.gz wird nur das finale .gz zurückgegeben. Es sind reine String-Operationen — kein Dateisystemzugriff.
const path = require('path');
const file = '/app/src/utils/helper.js';
path.dirname(file); // '/app/src/utils'
path.basename(file); // 'helper.js'
path.basename(file, '.js'); // 'helper' (strip ext)
path.extname(file); // '.js'
path.extname('archive.tar.gz'); // '.gz' (last ext)
// for the current file (CommonJS)
path.dirname(__filename); // current dir
path.basename(__filename); // current file namepath.parse & format
path.parse teilt einen Pfad in root, dir, base, name und ext. path.format setzt sie wieder zusammen. path.relative berechnet den relativen Pfad, der nötig ist, um von einem Verzeichnis zu einem anderen zu kommen. Zusammen machen sie Pfadmanipulation deklarativ statt fummeligem String-Slicing.
const path = require('path');
// decompose a path into parts
const p = path.parse('/app/src/helper.test.js');
// { root: '/', dir: '/app/src',
// base: 'helper.test.js', name: 'helper.test', ext: '.js' }
// rebuild from a parsed object
const rebuilt = path.format({
dir: '/app/dist',
name: 'bundle',
ext: '.min.js'
});
// '/app/dist/bundle.min.js'
// get the relative path from A to B
path.relative('/a/b/c', '/a/x'); // '../../x'Plattformübergreifende Pfade
path.sep und path.delimiter unterscheiden sich je OS. path.win32 und path.posix erzwingen einen bestimmten Parser unabhängig vom Host-OS — praktisch, um Pfade einer anderen Plattform zu verarbeiten. path.delimiter nutzen, um PATH-artige Env-Variablen portabel zu splitten, statt ':' oder ';' hart zu kodieren.
const path = require('path');
// platform-specific values
path.sep; // '/' (POSIX) or '\\' (Windows)
path.delimiter; // ':' (POSIX) or ';' (Windows)
// force a specific platform's behavior
path.win32.join('a', 'b'); // 'a\\b'
path.posix.join('a', 'b'); // 'a/b'
// parse PATH env var portably
process.env.PATH.split(path.delimiter).forEach(dir => {
console.log(dir);
});
// check if absolute
path.isAbsolute('/etc'); // true
path.isAbsolute('a/b'); // false
path.win32.isAbsolute('C:\\'); // trueFile-URLs & pathToFileURL
ES-Module werden durch file://-URLs identifiziert. url.pathToFileURL nutzt, um einen normalen Pfad in eine URL für dynamisches import() zu verwandeln, und url.fileURLToPath für den umgekehrten Weg. In ESM ist import.meta.url bereits eine File-URL — mit fileURLToPath in einen Pfad konvertieren, um __filename nachzubilden.
const path = require('path');
const url = require('url');
// convert a path to a file:// URL (ESM import)
const fileUrl = url.pathToFileURL('/app/src/mod.mjs');
// URL { href: 'file:///app/src/mod.mjs' }
// and back
const p = url.fileURLToPath('file:///app/src/mod.mjs');
// '/app/src/mod.mjs'
// in ESM, import.meta.url is already a file URL
// convert to a normal path:
import { fileURLToPath } from 'url';
const __filename = fileURLToPath(import.meta.url);HTTP-Server
Einfacher HTTP-Server
http.createServer liefert einen Server; der Callback behandelt jeden Request. res.writeHead setzt Statuscode und Header, res.end sendet den Body und beendet die Antwort. listen() nimmt Verbindungen auf dem angegebenen Port an. Ein Node-Prozess behandelt viele gleichzeitige Requests über die Event-Loop.
const http = require('http');
const server = http.createServer((req, res) => {
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('Hello, World!\n');
});
// listen on a port
server.listen(3000, () => {
console.log('Server running on http://localhost:3000');
});
// or with a host and backlog
server.listen(3000, '127.0.0.1', 511, () => {});Request & Response
req exponiert method, url und headers; res erlaubt statusCode/Headers zu setzen, dann write+end. res.end MUSS aufgerufen werden, um die Antwort zu beenden. Bei großen Payloads Daten über res.write streamen oder ein Readable in res pipen, um nicht alles im Speicher zu puffern.
const http = require('http');
http.createServer((req, res) => {
// request info
console.log(req.method); // 'GET'
console.log(req.url); // '/users?id=5'
console.log(req.headers); // { host, 'user-agent', ... }
// response helpers
res.statusCode = 200;
res.setHeader('Content-Type', 'application/json');
res.write('partial chunk\n');
res.end(JSON.stringify({ ok: true }));
}).listen(3000);
// streaming a large response
res.writeHead(200);
readStream.pipe(res); // pipe file -> responseRouting & URL-Parsing
Node hat keinen eingebauten Router — einen mit if/else auf req.method und req.url implementieren, oder den URL-Konstruktor zum Parsen von pathname und searchParams nutzen. Für echte Apps Express oder den Router eines Frameworks einsetzen. Der URL-Konstruktor braucht eine Basis beim Parsen eines relativen req.url.
const http = require('http');
const { URL } = require('url');
http.createServer((req, res) => {
const url = new URL(req.url, 'http://localhost');
const path = url.pathname;
const q = url.searchParams.get('id');
if (req.method === 'GET' && path === '/') {
res.end('home');
} else if (path === '/users') {
res.end('users');
} else {
res.writeHead(404);
res.end('not found');
}
}).listen(3000);JSON & POST-Body behandeln
Request-Bodies kommen als Stream an — Chunks müssen vor dem Parsen gesammelt werden. Das async-Iterator-Muster (for await of req) ist der moderne Ansatz. Beim Antworten mit JSON immer Content-Type: application/json setzen. In Produktion die Body-Größe begrenzen, um Speicherausschöpfung zu verhindern.
const http = require('http');
http.createServer(async (req, res) => {
if (req.method === 'POST') {
// collect the streamed body
const chunks = [];
for await (const chunk of req) chunks.push(chunk);
const body = JSON.parse(Buffer.concat(chunks).toString());
res.writeHead(200, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ received: body }));
}
}).listen(3000);
// test: curl -X POST localhost:3000 -d '{"a":1}'Server-Events & Fehler
Der Server ist ein EventEmitter. 'error' muss behandelt werden — EADDRINUSE heißt, der Port ist belegt. 'connection' feuert pro Client-Socket. Fürs graceful Shutdown auf SIGTERM/SIGINT hören und server.close() aufrufen, damit laufende Requests fertig werden, bevor der Prozess endet.
const server = http.createServer(handler);
server.on('listening', () => console.log('ready'));
server.on('connection', socket => console.log('client connected'));
server.on('error', err => {
if (err.code === 'EADDRINUSE') {
console.error('port 3000 already in use');
}
});
server.on('close', () => console.log('server closed'));
// graceful shutdown
process.on('SIGTERM', () => {
server.close(() => process.exit(0));
});
server.listen(3000);HTTPS & HTTP-Client
https.createServer braucht einen privaten Schlüssel und ein Zertifikat (z. B. von Let's Encrypt). Für ausgehende Requests liefert Node 18+ ein globales fetch() — dem rohen http.get-Callback-API vorziehen. fetch ist promise-basiert und unterstützt async/await, Header und Streams.
// HTTPS server (needs TLS certs)
const https = require('https');
const fs = require('fs');
https.createServer({
key: fs.readFileSync('key.pem'),
cert: fs.readFileSync('cert.pem')
}, handler).listen(443);
// HTTP client: simple GET
http.get('http://example.com', res => {
let data = '';
res.on('data', c => data += c);
res.on('end', () => console.log(data));
});
// modern fetch (Node 18+, global, promise-based)
const res = await fetch('https://api.example.com');
const json = await res.json();Express-Grundlagen
Express einrichten & Hello World
Express ist das beliebteste Node-Webframework. app.get registriert einen Routen-Handler; res.send sendet eine Antwort (mit automatischer Content-Type-Erkennung). app.listen startet den Server. Express umhüllt Node-Modul http mit Routing, Middleware und Komfort-Helfern.
// install: npm install express
import express from 'express';
const app = express();
const PORT = 3000;
app.get('/', (req, res) => {
res.send('Hello, World!');
});
app.listen(PORT, () => {
console.log(`Server on http://localhost:${PORT}`);
});Routing & Routen-Parameter
Express matcht HTTP-Methoden (get/post/put/delete) auf Pfade. :id fängt URL-Segmente in req.params ein; req.query hält Query-String-Werte. app.route erlaubt es, mehrere Methoden für denselben Pfad zu ketten. Routen matchen in Registrierungsreihenfolge — spezifische Routen also vor generischen definieren.
app.get('/users', (req, res) => res.send('list users'));
app.post('/users', (req, res) => res.send('create user'));
// URL parameters
app.get('/users/:id', (req, res) => {
res.send(`user ${req.params.id}`);
});
// query strings: /search?q=node
app.get('/search', (req, res) => {
res.send(`searching: ${req.query.q}`);
});
// chain handlers for one path
app.route('/book')
.get((req, res) => res.send('get book'))
.post((req, res) => res.send('add book'));Middleware
Middleware sind Funktionen, die im Request-Zyklus laufen und req, res und next erhalten. next() aufrufen, um zum nächsten Handler weiterzugehen. app.use mountet Middleware global oder auf einem Pfadpräfix. Fehlerbehandelnde Middleware hat 4 Argumente (err zuerst) und sollte zuletzt registriert werden.
// middleware: (req, res, next) => {}
app.use(express.json()); // parse JSON bodies
app.use(express.static('public'));// serve static files
app.use((req, res, next) => { // custom logger
console.log(req.method, req.url);
next(); // pass control forward
});
// mounted on a path
app.use('/api', (req, res, next) => {
req.apiCall = true;
next();
});
// error-handling middleware (4 args)
app.use((err, req, res, next) => {
console.error(err.stack);
res.status(500).send('Server Error');
});Request-Daten
Express parst Bodies nur, wenn die passende Middleware gemountet ist: express.json() für JSON, express.urlencoded() für Formulare, multer für Dateiuploads. req.params (URL-Segmente), req.query (Query-String) und req.body (geparste Payload) sind die drei Hauptquellen für Request-Daten.
// JSON body (needs express.json() middleware)
app.post('/api', (req, res) => {
console.log(req.body); // parsed JSON object
});
// URL params and query
app.get('/u/:id', (req, res) => {
const { id } = req.params;
const { tab } = req.query;
});
// form data (urlencoded)
app.use(express.urlencoded({ extended: true }));
app.post('/form', (req, res) => res.json(req.body));
// file uploads: use multer middleware
// const upload = multer({ dest: 'uploads/' });
// app.post('/upload', upload.single('file'), handler);
// headers & cookies
req.headers['user-agent'];
req.cookies; // needs cookie-parserStatische Dateien ausliefern
express.static liefert Dateien aus einem Verzeichnis aus. Mehrfach mounten für Fallback-Verhalten oder mit Pfadpräfix. Optionen wie maxAge setzen Caching-Header. Es erkennt MIME-Typen automatisch und unterstützt Range-Requests für Video/Audio. Immer absolute Pfade verwenden, um cwd-abhängige Bugs zu vermeiden.
const path = require('path');
// serve files from /public at /
app.use(express.static('public'));
// GET /style.css -> public/style.css
// mount at a prefix
app.use('/static', express.static('public'));
// GET /static/style.css -> public/style.css
// multiple directories (fallthrough)
app.use(express.static('public'));
app.use(express.static('uploads'));
// absolute path + options
app.use(express.static(path.join(__dirname, 'public'), {
maxAge: '1d',
setHeaders: (res, filePath) => {
if (filePath.endsWith('.html')) res.setHeader('Cache-Control', 'no-cache');
}
}));Fehlerbehandlung & Router
Einen Fehler an next(err) übergeben oder in einem async-Handler werfen, um fehlerbehandelnde Middleware auszulösen. Einen zentralen 4-Argument-Handler zuletzt registrieren. express.Router() modularisiert Routen in separate Dateien — mit app.use('/prefix', router) mounten, um eine große API sauber zu komponieren.
// throw to jump to error middleware
app.get('/broken', (req, res, next) => {
const err = new Error('boom');
err.status = 400;
next(err); // or throw err (Express 4+)
});
// centralized error handler (last middleware)
app.use((err, req, res, next) => {
const status = err.status || 500;
res.status(status).json({ error: err.message });
});
// modular routing with express.Router()
const router = express.Router();
router.get('/', (req, res) => res.send('api root'));
router.get('/users', (req, res) => res.send('users'));
app.use('/api', router); // mount at /apiStreams
Readable-Streams
Ein Readable-Stream erzeugt Daten. Im flowing-Modus schieben 'data'-Events Chunks automatisch; im paused-Modus ruft man read() explizit auf. 'error' immer behandeln — unbehandelte Error-Events crashen den Prozess. highWaterMark steuert die interne Buffer-Größe.
const fs = require('fs');
// create a readable stream from a file
const rs = fs.createReadStream('big.log', { highWaterMark: 64 * 1024 });
// 'data' mode (flowing)
rs.on('data', chunk => {
console.log('got', chunk.length, 'bytes');
});
rs.on('end', () => console.log('done'));
rs.on('error', err => console.error(err));
// paused mode: pull on demand
rs.on('readable', () => {
let chunk;
while ((chunk = rs.read()) !== null) {
process(chunk);
}
});Writable-Streams
Ein Writable-Stream konsumiert Daten. write() liefert false, wenn der interne Buffer voll ist — auf das 'drain'-Event warten, bevor mehr geschrieben wird, um Backpressure zu respektieren. end() signalisiert keine weiteren Daten; 'finish' feuert, nachdem alles gespült ist. process.stdout ist selbst ein Writable-Stream.
const fs = require('fs');
const ws = fs.createWriteStream('out.log');
// write returns false when the buffer is full (backpressure)
const ok = ws.write('line\n');
if (!ok) ws.once('drain', () => writeMore());
// signals completion
ws.end('final line\n');
ws.on('finish', () => console.log('all data flushed'));
ws.on('error', err => console.error(err));
// process.stdout is a writable stream
process.stdout.write('hello');pipe & pipeline
pipe() reicht einen Readable an einen Writable mit automatischer Backpressure weiter. stream.pipeline (die Promise-Version bevorzugen) verkettet mehrere Streams UND propagiert Fehler sauber und räumt auf — .pipe() allein verliert Ressourcen bei Fehlern mitten im Stream. Immer pipeline statt manueller .pipe()-Ketten.
const fs = require('fs');
const { pipeline } = require('stream/promises');
// pipe: readable -> writable (auto backpressure)
fs.createReadStream('in.txt')
.pipe(fs.createWriteStream('out.txt'));
// pipeline: chain transforms, with error handling
const { Transform } = require('stream');
const upper = new Transform({
transform(chunk, enc, cb) { cb(null, chunk.toString().toUpperCase()); }
});
await pipeline(
fs.createReadStream('in.txt'),
upper,
fs.createWriteStream('out.txt')
);
// pipeline rejects on error, unlike .pipe()Transform-Streams
Ein Transform-Stream liest Eingaben, verarbeitet sie und emittiert transformierte Ausgaben — perfekt fürs Parsen, Komprimieren oder Verschlüsseln in einer Pipeline. transform(chunk, enc, cb) implementieren und optional flush(cb). objectMode erlaubt Objekte statt Buffers zu pushen. zlib und crypto liefern fertige Transforms.
const { Transform } = require('stream');
// a Transform is both Readable and Writable
const csvToJson = new Transform({
objectMode: false,
transform(chunk, encoding, callback) {
// convert each chunk
const lines = chunk.toString().trim().split('\n');
const json = lines.map(l => JSON.stringify(l.split(','))).join('\n');
callback(null, json + '\n');
},
flush(callback) {
callback(null, ']\n'); // finalize
}
});
process.stdin.pipe(csvToJson).pipe(process.stdout);
// built-in transforms: zlib, crypto streams
const { createGzip } = require('zlib');
fs.createReadStream('log').pipe(createGzip()).pipe(fs.createWriteStream('log.gz'));Stream-Modi & Backpressure
Streams wechseln über pause()/resume() zwischen flowing- und paused-Modus. Backpressure heißt: Ein langsamer Konsument signalisiert dem Produzenten langsamer zu werden — async-Iteration (for await) handhabt das automatisch durch Awaiting jedes Chunks, das sauberste moderne Muster. Immer ein Encoding setzen, um Strings statt Buffers zu erhalten.
const rs = fs.createReadStream('huge.bin');
// switch between modes
rs.pause();
rs.resume();
rs.setEncoding('utf8');
// respect backpressure manually
function writeChunk(ws, data) {
if (!ws.write(data)) {
rs.pause();
ws.once('drain', () => rs.resume());
}
}
// async iteration (Node 10+) — cleanest pattern
async function consume() {
for await (const chunk of rs) {
await handle(chunk); // naturally respects backpressure
}
}
consume();Eigene Streams
Readable/Writable/Duplex subklassen und _read/_write implementieren, oder den einfacheren Readable.from() für bereits vorhandene Daten nutzen. push(null) signalisiert das Stream-Ende. Duplex-Streams sind lesbar UND schreibbar unabhängig (wie TCP-Sockets); Transform ist ein Duplex, dessen Ausgabe aus der Eingabe abgeleitet wird.
const { Readable, Writable, Duplex } = require('stream');
// custom Readable: generate a counter
const counter = new Readable({
read() {
if (++this._n > 10) this.push(null); // end
else this.push(String(this._n));
}
});
counter._n = 0;
counter.pipe(process.stdout);
// from an array / async iterable
Readable.from(['a', 'b', 'c']).pipe(process.stdout);
// a Duplex: both readable and writable (e.g. a socket)
class Echo extends Duplex {
_read() {}
_write(chunk, enc, cb) { this.push(chunk); cb(); }
}Buffer
Buffers erzeugen
Buffer.alloc erzeugt einen mit Nullen gefüllten Buffer (sicher). Buffer.allocUnsafe überspringt das Nullen für Tempo, kann aber alten Speicher leaken — nur verwenden, wenn jedes Byte überschrieben wird. Buffer.from konvertiert Strings/Arrays/Buffer. Der veraltete 'new Buffer()'-Konstruktor ist aus Sicherheitsgründen deprecated.
// allocate zeroed bytes (SAFE)
const b1 = Buffer.alloc(8); // <Buffer 00 00 00 00 00 00 00 00>
// allocate WITHOUT zeroing (faster, may contain old memory)
const b2 = Buffer.allocUnsafe(8); // random old data!
// from a string with encoding
const b3 = Buffer.from('hello', 'utf8');
// <Buffer 68 65 6c 6c 6f>
// from an array of bytes
const b4 = Buffer.from([0x48, 0x49]); // 'HI'
// from another buffer (copy)
const b5 = Buffer.from(b3);
// NEVER use new Buffer() — deprecated and unsafeLesen & Schreiben
Buffer halten rohe Bytes. Read-/Write-Methoden mit expliziten Größen (UInt8/16/32) und Byte-Reihenfolge (BE/LE) nutzen. Big-Endian ist die Netzwerk-Byte-Reihenfolge; Little-Endian ist auf x86 üblich. toString(encoding, start, end) dekodiert Bytes zu einem String. Immer einen Offset übergeben, um frühere Bytes nicht zu überschreiben.
const buf = Buffer.alloc(8);
// write numeric values at an offset
buf.writeUInt8(255, 0); // 1 byte
buf.writeUInt16BE(0x1234, 1); // 2 bytes, big-endian
buf.writeInt32LE(1000, 3); // 4 bytes, little-endian
// read them back
buf.readUInt8(0); // 255
buf.readUInt16BE(1); // 0x1234
buf.readInt32LE(3); // 1000
// string read/write
buf.write('Hi', 0, 'utf8');
buf.toString('utf8', 0, 2); // 'Hi'Concat & Compare
Buffer.concat verbindet ein Array von Buffers (ein optionaler Gesamt-Längen-Hinweis verbessert die Performance). equals/compare erlauben den Vergleich von Bytefolgen; indexOf/includes finden Sub-Buffer — nützlich in Binärprotokollen. copy(target, targetStart, sourceStart, sourceEnd) kopiert einen Ausschnitt in einen anderen Buffer.
const a = Buffer.from('foo');
const b = Buffer.from('bar');
// concatenate buffers
const c = Buffer.concat([a, b]); // 'foobar'
Buffer.concat([a, b], 6); // total length hint
// compare
Buffer.compare(a, b); // -1 (a < b), 0, or 1
a.equals(b); // false
// find a sub-buffer
const big = Buffer.from('hello world');
big.indexOf(Buffer.from('world')); // 6
big.includes(Buffer.from('hello')); // true
// copy bytes
const target = Buffer.alloc(5);
big.copy(target, 0, 0, 5); // copy first 5 bytesEncodings
Encodings mappen zwischen Strings und Bytes. utf8 ist der Standard für Text. base64/hex sind üblich für Binär-in-Text (Data-URLs, Hashes, Transport). Buffer.byteLength liefert die Byte-Größe (Mehrfach-Byte-Zeichen zählen in utf8 mehr als ein Byte) — beim Bemessen von Buffers nutzen, nicht string.length.
const text = 'Hello, 世界';
// string -> buffer (encode)
const utf8 = Buffer.from(text, 'utf8');
const base64 = Buffer.from(text).toString('base64');
const hex = Buffer.from(text).toString('hex');
const latin1 = Buffer.from(text, 'latin1');
// buffer -> string (decode)
utf8.toString('utf8'); // 'Hello, 世界'
Buffer.from(base64, 'base64').toString('utf8');
Buffer.from(hex, 'hex').toString('utf8');
// common encodings: utf8, utf16le, latin1, ascii,
// base64, base64url, hex
Buffer.byteLength('世界', 'utf8'); // 6 bytes (not 2)Buffer & TypedArrays
Buffer erweitert Uint8Array, funktioniert also überall, wo TypedArrays funktionieren. Buffer.from(arrayBuffer) teilt Speicher (keine Kopie) — aber ein Buffer kann einen größeren gepoolten ArrayBuffer anschneiden, also byteOffset/byteLength beim Erzeugen von Views immer beachten. So lassen sich Buffer-APIs mit DataView für feingranularen Zahlenzugriff mischen.
// Buffer is a subclass of Uint8Array
const buf = Buffer.from([1, 2, 3]);
buf instanceof Uint8Array; // true
// share memory with TypedArrays without copying
const u8 = new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
view.getInt32(0);
// Buffer from an ArrayBuffer
const ab = new ArrayBuffer(8);
const buf2 = Buffer.from(ab);
// note: a Buffer's underlying buffer may be larger
// (allocUnsafe pools) -> always use byteOffsetSlice, Fill, Swap
subarray (oder slice) gibt eine Sicht zurück, die den Originalspeicher teilt — Mutationen wirken auf beide. fill schreibt ein Byte oder einen wiederholten String über den Buffer. swap16/swap32 drehen die Byte-Reihenfolge in place für Endianness-Konvertierung. Buffer sind iterierbar und liefern jeden Bytewert 0–255.
const buf = Buffer.from('abcdef');
// slice shares memory (no copy) — like subarray
const s = buf.subarray(1, 4); // 'bcd'
s[0] = 88; // mutates buf too -> 'aXcdef'
// fill with a value or pattern
Buffer.alloc(4).fill(0xff); // <Buffer ff ff ff ff>
Buffer.alloc(6).fill('ab'); // 'ababab'
// reverse byte order in place (for endianness swaps)
const n = Buffer.from([0x01, 0x02, 0x03, 0x04]);
n.swap16(); // swaps pairs: <Buffer 02 01 04 03>
// iterate with for...of
for (const byte of buf) console.log(byte); // 97, 98, ...EventEmitter
Events erzeugen & emittieren
EventEmitter ist Node's Pub/Sub-Kern. emit(eventName, ...args) feuert ein Event; on() abonniert. Viele eingebaute Klassen (Streams, HTTP-Server) erweitern es. Event-Namen sind beliebige Strings, nur 'error' ist besonders. Listener werden synchron in Registrierungsreihenfolge aufgerufen.
const { EventEmitter } = require('events');
class Clock extends EventEmitter {
start() {
this.emit('start', Date.now()); // emit with args
setInterval(() => this.emit('tick', new Date()), 1000);
}
}
const clock = new Clock();
clock.on('tick', date => console.log('tick', date));
clock.on('start', ts => console.log('started at', ts));
clock.start();
// on() == addListener; once() fires only onceonce & removeListener
once() registriert einen Listener, der sich nach dem Feuern selbst entfernt — ideal für einmalige Einrichtung. Um einen Listener zu entfernen, braucht man eine Referenz auf die exakte Funktion (Arrow-Funktionen erzeugen jedes Mal neue Referenzen). removeAllListeners löscht Listener für ein oder alle Events. off ist ein Alias für removeListener.
const ee = new EventEmitter();
// once: auto-removed after first fire
ee.once('init', () => console.log('init fired'));
// remove a specific listener (need the same function ref)
const handler = () => console.log('hi');
ee.on('msg', handler);
ee.off('msg', handler); // off() == removeListener
// remove all listeners for an event (or all events)
ee.removeAllListeners('msg');
ee.removeAllListeners(); // everything
// inspect
ee.listenerCount('msg');
ee.eventNames(); // ['msg', 'init']Error-Events
Wird ein 'error'-Event emittiert und KEIN Listener registriert, wirft Node und crashet den Prozess. An EventEmittern immer einen Error-Handler anhängen — besonders bei Streams und HTTP-Servern. captureRejections (Node 12+) routet abgelehnte Promises von async Listenern zum 'error'-Event.
const ee = new EventEmitter();
// 'error' is special: if unhandled, it CRASHES the process
ee.on('error', err => {
console.error('caught:', err.message);
});
// later, emit an error safely
ee.emit('error', new Error('something broke'));
// guard against crashes from unhandled errors
// (monitor with the static capture)
EventEmitter.captureRejections = true; // for async handlers
// always register an error listener on streams/httpAsync-Listener
EventEmitter ruft Listener synchron auf, das Promise eines async Listeners wird also nicht awaited — emit() kehrt zurück, bevor es sich erfüllt. once(ee, name) nutzen, um ein einzelnes Event als Promise zu erwarten. captureRejections aktivieren, damit ein abgelehnter async Listener das 'error'-Event auslöst statt stillschweigend verloren zu gehen.
const ee = new EventEmitter();
// listeners run synchronously; await doesn't pause the chain
ee.on('save', async () => {
await fs.promises.writeFile('x', 'y');
console.log('saved');
});
ee.emit('save'); // returns before the await finishes
// wait for async listeners in sequence
const { once } = require('events');
async function waitForReady() {
await once(ee, 'ready'); // promise resolves on first 'ready'
console.log('now ready');
}
// handle async errors properly
EventEmitter.captureRejections = true;
ee.on('job', async () => { throw new Error('boom'); });
ee.on('error', err => console.error(err));Event-Namen & newListener
newListener und removeListener sind besondere Events, die beim Hinzufügen/Entfernen von Listenern emittiert werden — nützlich für Hooks oder Profiling. setMaxListeners erhöht die Leck-Erkennungsschwelle (Standard 10); die Warnung heißt meist, man hat vergessen Listener aufzuräumen. Symbols oder Konstanten für Eventnamen nutzen, um Tippfehler zu vermeiden.
const ee = new EventEmitter();
// special events fired by EventEmitter itself
ee.on('newListener', (event, listener) => {
console.log('listener added for', event);
});
ee.on('removeListener', (event, listener) => {
console.log('listener removed for', event);
});
// limit listener count to catch leaks
ee.setMaxListeners(20);
ee.getMaxListeners(); // 20
// MaxListenersExceededWarning fires if exceeded
// convention: camelCase event names, 'error' reserved
// prefer symbols/const strings to avoid typos
const READY = Symbol('ready');
ee.emit(READY);Child Process
exec (Shell, gepuffert)
exec() führt einen Befehl über eine Shell aus und puffert stdout/stderr — am besten für kurze Befehle, bei denen du die ganze Ausgabe auf einmal willst. Er spawnet eine Shell, expandiert also Globs und Pipes. NIE Nutzereingaben in den Befehlsstring interpolieren — das ist eine Command-Injection-Schwachstelle; stattdessen spawn mit einem Args-Array verwenden.
const { exec } = require('child_process');
// runs a command in a shell, buffers all output
exec('ls -la', (err, stdout, stderr) => {
if (err) { console.error('failed:', err); return; }
console.log(stdout); // full stdout as a string
console.error(stderr);
});
// promisified (Node 12+)
const { promisify } = require('util');
const execP = promisify(exec);
const { stdout } = await execP('git rev-parse HEAD');
// WARNING: shell interpolation = injection risk!
// NEVER: exec(`rm ${userInput}`)spawn (Streaming, ohne Shell)
spawn() startet einen Prozess mit einem Args-Array (keine Shell) und streamt stdout/stderr — sicher und speichereffizient für große oder langlebige Ausgaben. Weil Args direkt übergeben werden (nicht durch eine Shell), gibt es keine Glob-Expansion oder Injection-Risiko. Child-Streams an andere Streams pipen für Pipelines.
const { spawn } = require('child_process');
// no shell by default -> safe, stream-based
const child = spawn('ls', ['-la', '/tmp']);
child.stdout.on('data', chunk => process.stdout.write(chunk));
child.stderr.on('data', chunk => process.stderr.write(chunk));
child.on('close', code => console.log('exit code', code));
child.on('error', err => console.error('failed to spawn', err));
// pipe streams directly
const gzip = spawn('gzip');
process.stdin.pipe(gzip.stdin);
gzip.stdout.pipe(process.stdout);execFile & fork
execFile führt ein Programm ohne Shell aus — sicherer als exec, um ein bekanntes Binary mit Args auszuführen. fork() spawnet einen Node-Prozess und öffnet einen eingebauten IPC-Kanal (send/on('message')), die Basis für Cluster und worker_threads-artige Nachrichtenübermittlung zwischen Node-Prozessen.
const { execFile, fork } = require('child_process');
// execFile: like exec but no shell (safer, slight overhead saving)
execFile('node', ['--version'], (err, stdout) => {
console.log(stdout.trim()); // v20.x.x
});
// fork: spawn another Node process with an IPC channel
const worker = fork('./worker.js');
worker.send({ task: 'compute', n: 100 });
worker.on('message', msg => console.log('result:', msg));
worker.on('exit', code => console.log('worker exited', code));
// in worker.js:
// process.on('message', msg => { process.send(result); });stdio & Argumente
stdio steuert die Standard-Streams des Kindes: 'inherit' teilt das Eltern-Terminal (super für npm-Skripte), 'ignore' verwirft, 'pipe' fängt ab. detached + unref() spawnet einen Hintergrundprozess, der den Eltern überlebt. Argumente als Array übergeben — spawn quotiert sie, Leerzeichen und Sonderzeichen sind also sicher.
const { spawn } = require('child_process');
// control stdio: 'pipe' (default), 'inherit', 'ignore', or fd
const child = spawn('npm', ['test'], {
stdio: 'inherit' // child uses parent's stdin/stdout/stderr
});
// per-stream: [stdin, stdout, stderr]
spawn('cat', [], { stdio: ['pipe', process.stdout, 'ignore'] });
// set env, cwd, and detached background process
const bg = spawn('node', ['server.js'], {
cwd: '/app',
env: { ...process.env, NODE_ENV: 'production' },
detached: true // runs independently of parent
});
bg.unref(); // let parent exit without waiting
// pass arguments safely as array (no shell parsing)
spawn('echo', ['hello world']); // one arg, no quotes neededExit-Codes & Signale
Das 'exit'-Event meldet code (null, wenn durch ein Signal getötet) und signal (null bei normalem Ende). 'close' feuert, nachdem alle stdio-Streams geschlossen sind — verwenden, wenn du gepiped hast und wissen willst, dass die Streams gespült sind. kill() sendet ein Signal; SIGTERM ist sanft, SIGKILL ist nicht abfangbar.
const child = spawn('sleep', ['60']);
// 'exit' fires with code + signal
child.on('exit', (code, signal) => {
if (code === 0) console.log('success');
else if (signal) console.log('killed by', signal);
else console.log('failed with code', code);
});
// send a signal to the child (SIGTERM by default)
setTimeout(() => child.kill('SIGTERM'), 1000);
child.kill(); // default SIGTERM
child.kill('SIGKILL'); // force-kill (cannot be caught)
// 'close' vs 'exit': 'close' fires after streams are closed
child.on('close', code => console.log('streams closed', code));
// check if process is still running
child.killed; // true after kill() calledCluster
Einfaches Clustering
cluster erlaubt es, mehrere Node-Prozesse zu forken, die sich einen Port teilen, und über CPU-Kerne zu skalieren. Der Primary forkt Worker (typisch os.cpus().length). Jeder Worker ist ein vollständiger Node-Prozess mit demselben Skript. Worker bei 'exit' neu starten für Resilienz. cluster.isPrimary (früher isMaster) für Verzweigungen nutzen.
const cluster = require('cluster');
const http = require('http');
const os = require('os');
if (cluster.isPrimary) { // old: isMaster
// fork one worker per CPU core
for (let i = 0; i < os.cpus().length; i++) cluster.fork();
cluster.on('exit', (worker, code) => {
console.log(`worker ${worker.process.pid} died`);
cluster.fork(); // restart it
});
} else {
// workers share the same port
http.createServer((req, res) => res.end('hi'))
.listen(3000);
console.log('worker started', process.pid);
}Worker-Verwaltung
Der Primary verfolgt Worker über die Events 'online' (Prozess gestartet), 'listening' (Server gebunden), 'disconnect' und 'exit'. disconnect() leitet Verbindungen ab, bevor der Worker getötet wird — für Reloads ohne Ausfallzeit nutzen. cluster.workers mappt Worker-IDs auf Worker-Objekte, um ihnen Nachrichten zu senden oder sie zu schließen.
cluster.on('online', worker => {
console.log('worker responsive', worker.id);
});
cluster.on('listening', (worker, address) => {
console.log('worker bound to', address.port);
});
cluster.on('disconnect', worker => {
console.log('worker disconnected', worker.id);
});
// gracefully shut down a worker
const w = cluster.workers[1];
w.disconnect(); // stop accepting connections, then exit
w.send('shutdown'); // custom message
// iterate all workers
for (const id in cluster.workers) {
cluster.workers[id].send({ cmd: 'reload' });
}Geteilter Serverport
Alle Worker lauschen auf demselben Port; der Primary balanciert eingehende Verbindungen. SCHED_RR (Round-Robin, Standard auf den meisten Plattformen) verteilt gleichmäßig; SCHED_NONE überlässt es dem OS. State wird NICHT zwischen Workern geteilt — Redis oder eine Datenbank für geteilte Sessions/Cache nutzen.
const cluster = require('cluster');
const http = require('http');
if (cluster.isPrimary) {
cluster.schedulingPolicy = cluster.SCHED_RR; // round-robin (default on non-Windows)
cluster.fork();
cluster.fork();
} else {
// all workers call listen(3000) — primary load-balances
http.createServer((req, res) => {
res.end(`handled by ${process.pid}`);
}).listen(3000);
}
// SCHED_RR: primary distributes connections (default)
// SCHED_NONE: OS balances (may be uneven)Worker-Lifecycle & IPC
cluster.fork() öffnet einen IPC-Kanal (wie child_process.fork): worker.send und process.on('message') tauschen JSON zwischen Primary und Workern aus. Damit Jobs verteilen oder graceful Shutdown signalisieren. Bei CPU-lastiger Arbeit auch worker_threads erwägen, die Speicher teilen und den IPC-Overhead vermeiden.
// primary -> worker messaging
if (cluster.isPrimary) {
const worker = cluster.fork();
worker.on('message', msg => console.log('from worker:', msg));
worker.send({ task: 'heavy-compute' });
} else {
process.on('message', msg => {
console.log('from primary:', msg);
// do work, then report back
process.send({ done: true, result: 42 });
});
}
// graceful shutdown signal
process.on('message', msg => {
if (msg === 'shutdown') {
server.close(() => process.exit(0));
}
});Graceful Reload (keine Ausfallzeit)
Ein rollierender Neustart lädt Worker nacheinander neu, sodass die App nie ausfällt: Einen Worker disconnecten (nimmt keine neuen Verbindungen mehr an), auf sein Ende nach dem Abarbeiten warten, dann einen Ersatz forken. Mit SIGHUP auslösen. Immer mit einer 'shutdown'-Nachricht pro Worker kombinieren, damit jeder seinen Server schließt und erst nach Abschluss laufender Requests endet.
// rolling restart: reload workers one at a time
function reload() {
const workers = Object.values(cluster.workers || {});
let i = 0;
const next = () => {
if (i >= workers.length) return;
const w = workers[i++];
w.send('shutdown'); // tell worker to drain
w.disconnect(); // stop accepting connections
w.once('exit', () => {
cluster.fork(); // replacement ready
next(); // move to the next
});
};
next();
}
// trigger reload on SIGHUP
process.on('SIGHUP', reload);
// in the worker: finish in-flight requests then exit
process.on('message', msg => {
if (msg === 'shutdown') server.close(() => process.exit(0));
});Asynchrone Programmierung
Callbacks & Error-First-Konvention
Node's klassisches async-Muster ist der error-first-Callback: Das erste Argument ist ein Fehler (null bei Erfolg), die folgenden Argumente sind Ergebnisse. Immer zuerst err prüfen und bei Misserfolg früh zurückkehren. Dieser Stil skaliert schlecht mit Verschachtelung — bekannt als Callback Hell — moderne Nutzung also Promises und async/await.
// Node callbacks: (err, result) => {}
const fs = require('fs');
fs.readFile('data.txt', 'utf8', (err, data) => {
if (err) return console.error('read failed', err);
console.log(data);
});
// custom error-first function
function divide(a, b, cb) {
if (b === 0) return cb(new Error('divide by zero'));
cb(null, a / b);
}
divide(10, 2, (err, result) => {
if (err) return console.error(err);
console.log(result); // 5
});Promises
Ein Promise repräsentiert einen zukünftigen Wert. then() behandelt Erfolg, catch() Ablehnung, finally() läuft in beiden Fällen. then() ketten, um Werte sequenziell zu transformieren. util.promisify verwandelt eine error-first-Callback-Funktion in eine, die ein Promise zurückgibt — die Brücke von Legacy-APIs zu async/await.
// create a promise
const p = new Promise((resolve, reject) => {
setTimeout(() => resolve('done'), 100);
});
// consume with then/catch/finally
p.then(val => console.log(val)) // 'done'
.catch(err => console.error(err))
.finally(() => console.log('settled'));
// chain transforms
fetch(url)
.then(r => r.json())
.then(data => render(data));
// convert callback APIs
const { promisify } = require('util');
const readFile = promisify(fs.readFile);
const text = await readFile('x.txt', 'utf8');async/await
async/await lässt asynchronen Code synchron aussehen. Eine async-Funktion gibt ein Promise zurück; await pausiert, bis es sich erfüllt. Awaited-Aufrufe in try/catch hüllen, um Ablehnungen zu behandeln. Top-level-await ist in ES-Modulen erlaubt (und in CommonJS mit einem Flag) und macht den async-IIFE-Wrapper überflüssig.
// async functions always return a Promise
async function loadUser(id) {
const res = await fetch(`/api/users/${id}`);
if (!res.ok) throw new Error('not found');
return res.json();
}
// consume with try/catch
try {
const user = await loadUser(5);
console.log(user);
} catch (err) {
console.error('failed:', err);
}
// top-level await works in ESM and CommonJS (Node 14.8+)
const config = await loadConfig();Promise.all & allSettled
Promise.all läuft Promises parallel und löst mit einem Array von Ergebnissen auf, lehnt aber sofort ab, wenn IRGENDEIN Promise abgelehnt wird (fast-fail) — verwenden, wenn alle gelingen müssen. Promise.allSettled wartet auf jedes Promise unabhängig vom Ausgang und gibt {status, value/reason}-Objekte zurück — am besten, wenn Teilerfolg akzeptabel ist.
// all: run in parallel, reject fast on first failure
const [a, b, c] = await Promise.all([
fetch('/a').then(r => r.json()),
fetch('/b').then(r => r.json()),
fetch('/c').then(r => r.json())
]);
// allSettled: wait for ALL, never rejects
const results = await Promise.allSettled([
fetch('/x'),
fetch('/y'),
fetch('/z')
]);
results.forEach(r => {
if (r.status === 'fulfilled') console.log(r.value);
else console.error(r.reason); // rejected reason
});Promise.race & Promise.any
Promise.race löst auf ODER lehnt ab mit dem ersten Promise, das sich erfüllt — nützlich für Timeouts und das Wettracen von Mirrors. Promise.any löst mit dem ersten Erfolg auf und lehnt nur (AggregateError) ab, wenn jedes Promise scheitert — ideal für redundante Endpunkte, wo eine gesunde Antwort genügt.
// race: first to SETTLE (resolve or reject) wins
const fastest = await Promise.race([
fetch('/primary'),
fetch('/mirror'),
timeout(5000)
]);
// any: first to FULFILL wins; rejects only if ALL reject
const alive = await Promise.any([
fetch('/node1'),
fetch('/node2'),
fetch('/node3')
]);
// implement a timeout with race
function withTimeout(p, ms) {
return Promise.race([
p,
new Promise((_, reject) =>
setTimeout(() => reject(new Error('timeout')), ms))
]);
}Sequenziell vs. parallel
Awaiting in einer Schleife läuft sequenziell (langsam). Auf ein Array von Promises mappen und Promise.all darauf anwenden für Parallelität (schnell, aber unbegrenzte Nebenläufigkeit kann Ressourcen überfordern). Ein Pool mit Nebenläufigkeitsbegrenzung drosselt parallele Arbeit — essenziell beim Aufrufen ratenbegrenzter APIs oder schwerem I/O über Tausende Items.
// SEQUENTIAL: one after another (slow)
const results = [];
for (const url of urls) {
results.push(await fetch(url).then(r => r.json()));
}
// PARALLEL: fire all, await together (fast)
const results = await Promise.all(
urls.map(u => fetch(u).then(r => r.json()))
);
// THROTTLED: limit concurrency with a pool
async function mapLimit(items, limit, fn) {
const ret = [];
const executing = [];
for (const item of items) {
const p = Promise.resolve().then(() => fn(item));
ret.push(p);
if (executing.push(p) >= limit) {
await Promise.race(executing);
executing.splice(executing.findIndex(x => x === p), 1);
}
}
return Promise.all(ret);
}Fehlerbehandlung
try/catch/finally
try/catch behandelt synchrone Fehler und (mit await) async-Ablehnungen. finally läuft immer, auch bei return/throw — für Aufräumarbeiten wie das Schließen von Handles nutzen. Spezifische Fehler durch Prüfen von err.code abfangen und alles Unbekannte erneut werfen, damit unerwartete Bugs zutage treten statt verschluckt zu werden.
function parse(str) {
try {
return JSON.parse(str);
} catch (err) {
console.error('parse failed:', err.message);
return null;
} finally {
console.log('cleanup always runs');
}
}
// async errors need async catch
async function load() {
try {
const data = await fetchData();
return data;
} catch (err) {
if (err.code === 'ENOENT') return defaultData();
throw err; // re-throw unknown errors
}
}Error-First-Callbacks
In error-first-Callbacks immer zuerst err prüfen und früh zurückkehren — Daten niemals verwenden, wenn err gesetzt ist. Beim Umhüllen einer Callback-API den Fehler an den eigenen Callback weiterreichen, statt zu werfen (throws in Callbacks kann der Aufrufer nicht fangen). Sync-Code, der werfen kann (wie JSON.parse), in try/catch hüllen.
const fs = require('fs');
// ALWAYS check err first, return early
fs.readFile('missing.txt', 'utf8', (err, data) => {
if (err) {
console.error('could not read:', err.message);
return; // don't use data
}
console.log(data);
});
// propagate the error to your own caller
function readConfig(cb) {
fs.readFile('config.json', 'utf8', (err, raw) => {
if (err) return cb(err);
try { cb(null, JSON.parse(raw)); }
catch (e) { cb(e); }
});
}Uncaught Exceptions
uncaughtException feuert für synchrone Ausnahmen, die allen Handlern entkommen — der Prozess ist nun korrupt: loggen, Server schließen und beenden (ein Prozessmanager startet neu). unhandledRejection feuert für vergessene Promises; seit Node 15 crashet das den Prozess, also immer .catch() ergänzen oder in try/catch awaiten.
// last-resort handler for sync exceptions
process.on('uncaughtException', err => {
console.error('UNCAUGHT:', err);
// the process is in an unknown state — restart it
server.close(() => process.exit(1));
});
// rejected promises nobody awaited
process.on('unhandledRejection', (reason, promise) => {
console.error('UNHANDLED REJECTION:', reason);
});
// Node 15+: unhandled rejections terminate the process
// always add .catch() or wrap in try/awaitEigene Error-Klassen
Error subklassen, um strukturierte Felder (code, field, status) zu ergänzen und Fehlertypen mit instanceof zu unterscheiden. Immer this.name auf den Klassennamen setzen (nicht automatisch in älteren Zielen) und super(message) aufrufen. Eigene Fehler machen catch-Blöcke lesbar: auf instanceof verzweigen statt fragiler String-Matches.
// subclass Error to add context
class ValidationError extends Error {
constructor(field, message) {
super(message);
this.name = 'ValidationError';
this.field = field;
this.code = 'VALIDATION_FAILED';
}
}
function validate(email) {
if (!email.includes('@')) {
throw new ValidationError('email', 'invalid email');
}
}
// branch on error type with instanceof
try {
validate('no-at-sign');
} catch (err) {
if (err instanceof ValidationError) {
console.log(err.field, err.message);
} else {
throw err;
}
}Error-Eigenschaften & cause
Jedes Error hat message, name und stack. Eine code-Eigenschaft für stabile, maschinenlesbare Behandlung ergänzen (Node's eigene Fehler nutzen Codes wie ENOENT, EACCES). Die ES2022-Option cause (Node 16.9+) verkettet einen zugrunde liegenden Fehler, sodass du Low-Level-Fehlschläge einhüllen kannst, während der Originalstack fürs Debugging erhalten bleibt.
// built-in Error props
const e = new Error('something broke');
e.message; // 'something broke'
e.stack; // stack trace string
e.name; // 'Error'
// add a code for machine-readable handling
const err = new Error('file missing');
err.code = 'ENOENT';
err.errno = -2;
// Error.cause (Node 16.9+) — chain underlying errors
try {
JSON.parse(bad);
} catch (original) {
throw new Error('config parse failed', { cause: original });
}
// inspect the cause
console.log(err.cause); // the original SyntaxErrorDomains & Aufräumen
'beforeExit' für async-Aufräumarbeiten nutzen (es kann den Exit verschieben), 'exit' nur für synchrone Arbeit. SIGTERM (Container-Shutdown) und SIGINT (Ctrl-C) behandeln, um Verbindungen vor dem Beenden abzuarbeiten — einen Force-Exit-Timeout ergänzen, damit eine hängende Verbindung den Prozess nicht aufhält. Domains sind veraltet; try/catch und async-Fehlerbehandlung stattdessen verwenden.
// modern cleanup: 'beforeExit' for async, 'exit' for sync
process.on('beforeExit', async () => {
await closeDbConnections();
});
process.on('exit', code => {
// ONLY sync code allowed here — no async, no promises
console.log('exiting with', code);
});
// graceful signal handling
const shutdown = sig => {
console.log('got', sig);
server.close(() => process.exit(0));
setTimeout(() => process.exit(1), 5000).unref(); // force exit
};
process.on('SIGTERM', () => shutdown('SIGTERM'));
process.on('SIGINT', () => shutdown('SIGINT'));Debugging
console-Methoden
console bietet mehr als log: table rendert Arrays von Objekten, time/timeEnd misst Dauer, dir gibt ein Objekt mit konfigurierbarer Tiefe aus, trace druckt einen Stack und count zählt Treffer. console.error (stderr) nutzen, damit Logs und Fehler in Produktionspipelines getrennt werden können.
console.log('basic'); // stdout
console.error('oops'); // stderr
console.warn('careful'); // stderr
// formatted table
console.table([{ id: 1, n: 'A' }, { id: 2, n: 'B' }]);
// inspect an object in depth
console.dir(obj, { depth: null, colors: true });
// timing a block
console.time('loop');
for (let i = 0; i < 1e6; i++) {}
console.timeEnd('loop'); // loop: 3.2ms
// stack trace
console.trace('where am I');
// count calls
for (let i = 0; i < 3; i++) console.count('hit');node inspect & DevTools
--inspect startet den V8-Inspector, sodass Chrome DevTools (chrome://inspect) oder VS Code sich anhängen können. --inspect-brk pausiert in der ersten Zeile, damit du Breakpoints setzen kannst, bevor Startup-Code läuft. Das klassische 'node inspect' ist ein Terminal-Debugger, nützlich über SSH, wo kein Browser verfügbar ist.
# open Chrome DevTools debugger
node --inspect app.js
# visit chrome://inspect, click "inspect"
# pause on first line (break before anything runs)
node --inspect-brk app.js
# wait for a debugger client to attach
node --inspect-wait app.js
# the legacy CLI debugger (still works, no browser)
node inspect app.js
# > cont, step, next, breakpoints, replDie debugger-Anweisung
Die debugger-Anweisung pausiert die Ausführung NUR, wenn ein Debugger (DevTools oder VS Code) angehängt ist — sonst ist sie ein No-op und kann im Code bleiben. Mit --inspect-brk kombinieren, um beim Start zu stoppen. Für Ad-hoc-Inspektion debugger; in Schleifen oder Bedingungen einwerfen statt UI-Breakpoints zu setzen.
function findBug(arr) {
let sum = 0;
for (const n of arr) {
debugger; // pauses only when a debugger is attached
sum += n;
}
return sum;
}
// run with --inspect-brk to hit the breakpoint
// node --inspect-brk app.js
// conditional breakpoints in DevTools/VSCode:
// if (n > 100) { debugger; }VS-Code-Debugging
VS Code's Node-Debugger (F5) liest .vscode/launch.json. "request": "launch" führt das Programm mit eingebautem Inspector aus; "attach" verbindet sich mit einem bereits mit --inspect gestarteten Prozess. skipFiles verbirgt Node-Internas beim Steppen. Das "restart"-Flag oder nodemon nutzen, um bei Dateiänderungen neu zu starten.
// .vscode/launch.json
{
"version": "0.2.0",
"configurations": [
{
"type": "node",
"request": "launch",
"name": "Debug App",
"program": "${workspaceFolder}/app.js",
"skipFiles": ["<node_internals>/**"]
},
{
"type": "node",
"request": "attach",
"name": "Attach by PID",
"processId": "${command:PickProcess}"
}
]
}
// F5 to start; set breakpoints in the editor
// "restart": true, "nodemon" for auto-restart on changeWarnungen & Stacktraces
--trace-warnings druckt Stacks für Prozesswarnungen (Speicherlecks, veraltete APIs). --trace-deprecation legt Legacy-API-Nutzung offen; --throw-deprecation macht daraus harte Fehler für strengeres CI. --cpu-prof schreibt ein Profil, das du in Chrome DevTools öffnen kannst, um heiße Funktionen zu finden. Error.stackTraceLimit erhöhen für tiefere async-Traces.
# show stack traces for process warnings
node --trace-warnings app.js
# deprecation warnings (use --throw-deprecation to make them errors)
node --trace-deprecation app.js
# capture a stack trace manually
const e = new Error('here');
console.log(e.stack);
# show async stack traces (Node 12+ enabled by default)
Error.stackTraceLimit = 50; // deeper traces
# profile CPU usage
node --cpu-prof app.js # writes CPU.*.cpuprofile
# then load the file in Chrome DevToolsCrypto
Hashing (createHash)
createHash erzeugt einen einseitigen Digest. SHA-256 ist der moderne Standard für Checksummen und Signaturen; MD5/SHA-1 für Sicherheit vermeiden (kollisionsanfällig). Daten können inkrementell eingespeist werden, große Dateien lassen sich ohne Pufferung streamen. digest('hex') liefert einen Hex-String; 'base64' ist ebenfalls üblich. Hashing ist KEINE Passwortspeicherung — pbkdf2/scrypt verwenden.
const crypto = require('crypto');
// common hashes: sha256, sha512, md5 (insecure!), sha1
const hash = crypto.createHash('sha256');
hash.update('hello');
hash.update(' world'); // can chain updates
console.log(hash.digest('hex'));
// b94d... (64 hex chars)
// one-shot hashing
const h = crypto.createHash('sha256').update('data').digest('hex');
console.log(h);
// file hash (streaming)
const fs = require('fs');
const fhash = crypto.createHash('sha256');
fs.createReadStream('big.iso').on('data', c => fhash.update(c))
.on('end', () => console.log(fhash.digest('hex')));HMAC (createHmac)
HMAC signiert Daten mit einem geteilten Geheimnis, sodass der Empfänger Integrität und Authentizität verifizieren kann. Es ist die Basis von JWT-Signaturen und Webhook-Verifikation (GitHub, Stripe). Signaturen immer mit timingSafeEqual vergleichen — ein normales === leakt Information durch Timing-Unterschiede, die Angreifer ausnutzen können.
const crypto = require('crypto');
// HMAC = keyed hash (authenticity + integrity)
const secret = process.env.SECRET_KEY;
const hmac = crypto.createHmac('sha256', secret);
hmac.update('payload to sign');
const signature = hmac.digest('hex');
// verify a webhook signature (constant-time compare)
function verify(payload, receivedSig) {
const expected = crypto.createHmac('sha256', secret)
.update(payload).digest('hex');
// timingSafeEqual prevents timing attacks
return crypto.timingSafeEqual(
Buffer.from(expected),
Buffer.from(receivedSig)
);
}Random Bytes
crypto.randomBytes erzeugt kryptografisch sichere Zufallsdaten — für Tokens, IDs und Geheimnisse verwenden. Die async-Form vermeidet das Blockieren der Event-Loop bei der Erzeugung vieler Bytes. crypto.randomInt liefert unverzerrte Zufallszahlen, und randomUUID() erzeugt RFC-4122-v4-UUIDs. Math.random() niemals für sicherheitsrelevante Dinge verwenden.
const crypto = require('crypto');
// async (preferred — doesn't block the event loop)
crypto.randomBytes(16, (err, buf) => {
const token = buf.toString('hex'); // 32-char hex
});
// sync (blocks; fine for small sizes)
const id = crypto.randomBytes(8).toString('hex');
// random integer in [min, max)
const n = crypto.randomInt(1, 101); // 1..100
// random UUID (Node 14.17+)
const uuid = crypto.randomUUID();
// '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed'
// use crypto, NEVER Math.random() for secrets!Verschlüsselung (createCipheriv)
AES-256-GCM ist die empfohlene symmetrische Chiffre — sie ist authentifiziert, Manipulationen werden also erkannt. Der IV (Nonce) muss pro Verschlüsselung mit einem Schlüssel einzigartig sein (nie wiederverwenden); zusammen mit dem Chiffretext speichern. setAuthTag verifiziert die Integrität beim Entschlüsseln. Das veraltete createCipher nie verwenden (leitet Schlüssel unsicher ab) — immer createCipheriv mit einem ordentlichen Schlüssel.
const crypto = require('crypto');
const algorithm = 'aes-256-gcm';
// AES-256-GCM (authenticated encryption) ----------------
const key = crypto.randomBytes(32); // 256-bit key
const iv = crypto.randomBytes(12); // 96-bit nonce
function encrypt(text) {
const cipher = crypto.createCipheriv(algorithm, key, iv);
const enc = Buffer.concat([cipher.update(text, 'utf8'), cipher.final()]);
const tag = cipher.getAuthTag(); // GCM auth tag
return { enc, tag };
}
function decrypt(enc, tag) {
const decipher = crypto.createDecipheriv(algorithm, key, iv);
decipher.setAuthTag(tag); // verify integrity
return Buffer.concat([decipher.update(enc), decipher.final()]).toString('utf8');
}Passwort-Hashing (pbkdf2, scrypt)
Passwörter mit einem langsamen, gesalzenen KDF hashen — nie mit einem plain-Hash. pbkdf2 (Iterationen mit besserer Hardware erhöhen) und scrypt (memory-hard, GPU-resistent) sind in Node eingebaut. Iterationen, Salz und Hash zusammen speichern, damit du verifizieren und später Parameter anheben kannst. timingSafeEqual nutzen, um Hashes ohne Timing-Leak zu prüfen.
const crypto = require('crypto');
// PBKDF2: tuned with iterations
function hashPbkdf2(password) {
const salt = crypto.randomBytes(16);
const iterations = 100000;
const hash = crypto.pbkdf2Sync(password, salt, iterations, 64, 'sha256');
return `${iterations}.${salt.toString('hex')}.${hash.toString('hex')}`;
}
// scrypt: memory-hard, resistant to GPU/ASIC attacks
function hashScrypt(password) {
const salt = crypto.randomBytes(16);
const hash = crypto.scryptSync(password, salt, 64, { N: 16384 });
return salt.toString('hex') + '.' + hash.toString('hex');
}
// verify: re-hash with the same salt and compare
function verify(password, stored) {
const [iter, salt, hash] = stored.split('.');
const computed = crypto.pbkdf2Sync(password, Buffer.from(salt, 'hex'),
+iter, 64, 'sha256');
return crypto.timingSafeEqual(Buffer.from(hash, 'hex'), computed);
}Timing-sicherer Vergleich
timingSafeEqual vergleicht zwei Buffer in konstanter Zeit und verhindert Timing-Angriffe, bei denen ein Angreifer ein Geheimnis Byte für Byte aus Antwortverzögerungen ableitet. Beide Buffer müssen gleich lang sein (zuerst prüfen, aber der Längencheck selbst kann die Länge leaken — bei Geheimnissen beide Seiten vorher hashen). Immer beim Vergleichen von Tokens, Signaturen oder API-Schlüsseln.
const crypto = require('crypto');
// NORMAL compare leaks via timing (returns early on first diff)
// 'secret' === userInput // BAD for secrets
// timingSafeEqual takes equal-length Buffers
function safeEqual(a, b) {
const bufA = Buffer.from(a);
const bufB = Buffer.from(b);
if (bufA.length !== bufB.length) return false;
return crypto.timingSafeEqual(bufA, bufB);
}
// common use: API key check
function auth(req) {
const provided = req.headers['x-api-key'] || '';
return safeEqual(provided, process.env.API_KEY);
}OS-Modul
Systeminformationen
os legt die Host-Umgebung offen. platform/arch/type identifizieren das OS für Portabilitätschecks. os.EOL gibt die End-of-Line-Sequenz der Plattform — beim Schreiben plattformkorrekter Textdateien verwenden. hostname ist der Netzwerkname der Maschine, nützlich, um zu loggen, welche Instanz einen Request behandelt hat.
const os = require('os');
os.platform(); // 'linux', 'darwin', 'win32'
os.arch(); // 'x64', 'arm64'
os.type(); // 'Linux', 'Darwin', 'Windows_NT'
os.release(); // kernel version
os.hostname(); // machine hostname
os.uptime(); // seconds since boot
os.EOL; // '\n' (POSIX) or '\r\n' (Windows)
// detect platform portably
const isWin = os.platform() === 'win32';
const isMac = os.platform() === 'darwin';CPU-Info
os.cpus() liefert ein Array logischer Kerne (Hyperthreads eingeschlossen), seine Länge ist also der richtige Nebenläufigkeitshinweis für cluster.fork. Jeder Eintrag hat model, speed und times (user/sys/idle). loadavg meldet die Systemlast (nur Linux/macOS) — ein Wert über cpus().length deutet auf Sättigung.
const os = require('os');
// logical core count (threads, not physical)
os.cpus().length; // 8
// detailed per-core info
os.cpus().forEach((cpu, i) => {
console.log(`core ${i}: ${cpu.model} @ ${cpu.speed}MHz`);
});
// 1/5/15-minute load averages (NOT on Windows)
os.loadavg(); // [0.45, 0.32, 0.28]
// set process scheduling priority
os.setPriority(os.constants.priority.PRIORITY_BELOW_NORMAL);Speicher
os.totalmem/freemem melden den System-RAM, process.memoryUsage den Fußabdruck dieses Prozesses. rss ist der OS-Level-Speicher; heapUsed sind die lebenden JS-Objekte. heapUsed auf Lecks beobachten. Bytes in MB umrechnen durch Division durch 1024*1024 (1048576). --max-old-space-size tunen, wenn der Heap nahe am Limit wächst.
const os = require('os');
// system memory (bytes)
os.totalmem(); // e.g. 17179869184
os.freemem(); // currently free bytes
// process memory usage (bytes)
const m = process.memoryUsage();
m.rss; // resident set size (total RAM held)
m.heapTotal; // V8 heap allocated
m.heapUsed; // V8 heap actually used
m.external; // C++ objects bound to JS
m.arrayBuffers; // memory in ArrayBuffers
// human-readable
console.log(`heap: ${(m.heapUsed / 1048576).toFixed(1)} MB`);Netzwerkinterfaces
os.networkInterfaces() listet jedes Netzwerkinterface mit Adressen, MAC und Familie (IPv4/IPv6). Das 'internal'-Flag markiert Loopback. Der portable Weg, die LAN-IP der Maschine zu finden, etwa zum Binden von Servern oder fürs Logging. Jedes Interface kann mehrere Adressen haben (Multihomed-Hosts).
const os = require('os');
const nets = os.networkInterfaces();
for (const name of Object.keys(nets)) {
for (const net of nets[name]) {
console.log(`${name} ${net.family}: ${net.address} (${net.mac})`);
}
}
// en0 IPv4: 192.168.1.10 (aa:bb:cc:...)
// lo IPv4: 127.0.0.1 (:::...)
// find this machine's LAN IPv4
function getLanIp() {
for (const nets of Object.values(os.networkInterfaces())) {
for (const n of nets) {
if (n.family === 'IPv4' && !n.internal) return n.address;
}
}
return '127.0.0.1';
}Nutzer & Pfade
os.homedir liefert das Home-Verzeichnis des Nutzers und os.tmpdir den System-Temp-Ordner — beide plattformenkompatibel, also hartkodierten Pfaden vorziehen. os.userInfo gibt die Identität des aktuellen Nutzers. os.constants zentralisiert numerische Signal-/errno-/Prioritätswerte, sodass man keine Magic Numbers wie 15 für SIGTERM hartkodiert.
const os = require('os');
os.homedir(); // /home/alice or C:\Users\alice
os.tmpdir(); // /tmp or C:\Users\...\Temp
os.userInfo(); // { username, uid, gid, homedir, shell }
os.constants; // signal/errno/priority constants
// errno constants map
os.constants.errno.ENOENT; // -2
// signal constants
os.constants.signals.SIGTERM; // 15
// priority constants
os.constants.priority.PRIORITY_HIGH;
// build a portable temp path
const path = require('path');
const tmpFile = path.join(os.tmpdir(), 'app-' + Date.now() + '.log');Process
process.argv
process.argv hält Befehlszeilenargumente: argv[0] ist das node-Binary, argv[1] das Skript, der Rest sind Nutzerargumente. Die ersten beiden abschneiden, um nur die Nutzerargumente zu bekommen. Über Spielzeugsripte hinaus einen Parser wie minimist, yargs oder commander verwenden — sie handhaben Flags, Typen, Defaults und Hilfetext.
// argv[0] = node path, argv[1] = script path, argv[2+] = args
// node app.js --port 3000 users.csv
console.log(process.argv);
// ['/usr/bin/node', '/app/app.js', '--port', '3000', 'users.csv']
const args = process.argv.slice(2);
console.log(args); // ['--port', '3000', 'users.csv']
// minimal flag parsing
function parseArgs(arr) {
const out = { _: [] };
for (let i = 0; i < arr.length; i++) {
if (arr[i].startsWith('--')) out[arr[i].slice(2)] = arr[++i];
else out._.push(arr[i]);
}
return out;
}
// for real CLI use commander, yargs, or minimistprocess.env
process.env hält Umgebungsvariablen als Strings. Üblicherweise kommen PORT, NODE_ENV, DATABASE_URL und API_KEY aus der Env, damit derselbe Code über Umgebungen hinweg läuft. Das dotenv-Paket nutzen, um in der Entwicklung eine .env-Datei zu laden. Geheimnisse niemals committen — über Host-/CI-Umgebung injizieren.
// read environment variables
const port = process.env.PORT || 3000;
const dbUrl = process.env.DATABASE_URL;
const nodeEnv = process.env.NODE_ENV || 'development';
const isProd = process.env.NODE_ENV === 'production';
// set an env var (affects child processes too)
process.env.MY_VAR = 'value';
// load .env files (install: npm i dotenv)
// require('dotenv').config();
// enumerate everything
for (const [k, v] of Object.entries(process.env)) {
console.log(k, '=', v);
}process.exit & Exit-Codes
process.exit(n) beendet sofort, womöglich bevor I/O-Buffer gespült sind — lieber process.exitCode setzen und die Event-Loop natürlich ablaufen lassen. Exit 0 heißt Erfolg; Nicht-Null signalisiert Shells und CI einen Misserfolg. Die Konvention 128+N kodiert Beendigung durch Signal N (SIGTERM ergibt also 143).
// exit immediately with a status code
process.exit(0); // success
process.exit(1); // general failure
// exit code is also settable
process.exitCode = 2; // used if the loop ends naturally
// prefer setting exitCode + returning over process.exit()
// so async work can finish
// common conventions:
// 0 success
// 1 general error
// 2 misuse (bad args)
// 124 timeout (from the 'timeout' command)
// 128+N killed by signal N (e.g. 143 = SIGTERM)stdin / stdout / stderr
process.stdout und process.stderr sind Writable-Streams — write() fügt keinen Zeilenumbruch hinzu (anders als console.log). stdin ist ein Readable-Stream, den man über 'data'-Events oder async-Iteration konsumieren kann (das sauberste moderne Muster). stderr für Diagnostik nutzen, damit es in Pipes vom echten Output getrennt werden kann.
// stdout/stderr are writable streams
process.stdout.write('no newline');
process.stdout.write('line\n');
console.log === process.stdout.write.bind(...); // roughly
// stdin is a readable stream
process.stdin.setEncoding('utf8');
process.stdin.on('data', chunk => console.log('got:', chunk));
// read all of stdin (async iteration)
async function readStdin() {
let data = '';
for await (const chunk of process.stdin) data += chunk;
return data;
}
// ask a yes/no question
process.stdin.resume();
process.stdin.once('data', input => process.exit(input[0] === 'y'.charCodeAt(0) ? 0 : 1));Prozess-Events (Signale)
'exit' feuert, nachdem die Event-Loop geleert ist — dort läuft nur synchroner Code. 'beforeExit' kann async-Arbeit erledigen und den Exit verschieben. SIGINT (Ctrl-C) und SIGTERM (docker stop, kill) behandeln, um Server und DB-Verbindungen sanft zu schließen. Immer einen Force-Exit-Timeout setzen, damit eine hängende Verbindung den Prozess nicht für immer einsperrt.
// lifecycle events
process.on('exit', code => {
// sync only here — no async, no event loop
console.log('bye, code', code);
});
process.on('beforeExit', () => {
// async OK; can postpone exit
});
// signal handlers (Unix + Windows for SIGINT/SIGTERM)
process.on('SIGINT', () => { // Ctrl-C
console.log('graceful shutdown...');
server.close(() => process.exit(0));
});
process.on('SIGTERM', () => { // kill / docker stop
server.close(() => process.exit(0));
});
process.on('SIGHUP', () => reloadConfig());memoryUsage & uptime
process legt Identität offen (pid, ppid, platform, version) und Laufzeitstatistiken (uptime, memoryUsage, cpuUsage). cwd() ist das Arbeitsverzeichnis — chdir ändert es und wirkt auf die Auflösung relativer Pfade. memoryUsage und cpuUsage sind die Basis für Health-Check-Endpunkte und Autoscaling-Metriken.
// process info
process.pid; // OS process ID
process.ppid; // parent PID
process.platform; // 'linux', 'darwin', 'win32'
process.version; // 'v20.11.0'
process.versions; // { v8, openssl, modules, ... }
process.cwd(); // current working directory
process.uptime(); // seconds since process started
// change directory
process.chdir('/tmp');
// memory snapshot
const m = process.memoryUsage();
console.log(m.rss, m.heapUsed);
// CPU usage of this process
const cpu = process.cpuUsage();
console.log(cpu.user, cpu.system); // microsecondsNetzwerk (net)
TCP-Server
net.createServer macht einen rohen TCP-Server. Jede Verbindung ruft den Callback mit einem Socket (ein Duplex-Stream) auf. Mit 'data'-Events lesen, mit socket.write schreiben. 'error' an Sockets immer behandeln, sonst crasht der Prozess. TCP ist das Fundament unter HTTP — nützlich für eigene Protokolle, Spiele und Proxies.
const net = require('net');
const server = net.createServer(socket => {
console.log('client connected', socket.remoteAddress);
socket.write('welcome\n');
socket.on('data', data => {
socket.write('echo: ' + data); // echo back
});
socket.on('end', () => console.log('client left'));
socket.on('error', err => console.error('socket err', err));
});
server.listen(5000, () => {
console.log('TCP server on port 5000');
});
// test with: nc localhost 5000 or telnet localhost 5000TCP-Client
net.connect (Alias createConnection) öffnet einen TCP-Client-Socket. Der Callback feuert beim Verbinden; 'data'-Events liefern eingehende Bytes. Ein Encoding setzen, um Strings statt Buffers zu empfangen. Wie jeder Stream 'error' behandeln, um Crashes zu vermeiden. Sockets schließen sich automatisch bei 'end'; client.end() halb-dein-seitig schließen.
const net = require('net');
// connect to a TCP server
const client = net.connect(5000, 'localhost', () => {
console.log('connected');
client.write('hello server\n');
});
client.setEncoding('utf8');
client.on('data', data => console.log('server said:', data));
client.on('end', () => console.log('disconnected'));
client.on('error', err => console.error(err));
// or with an options object + timeout
const c = net.createConnection({
port: 5000,
host: 'localhost',
timeout: 5000
});Socket-Events & Daten
TCP ist ein Bytestream, kein Nachrichtenprotokoll — ein 'data'-Event entspricht nicht einer Nachricht; Daten können geteilt oder zusammengelegt werden. Nachrichten MUSST du selbst einrahmen (Längenpräfixe, Trennzeichen oder ein Parser). setKeepAlive erkennt tote Peers, setTimeout killt ungenutzte Verbindungen, und 'drain' signalisiert, dass der Schreibbuffer geleert wurde.
const net = require('net');
net.createServer(socket => {
socket.setEncoding('utf8');
socket.setKeepAlive(true, 30000); // enable TCP keepalive
socket.setTimeout(60000); // idle timeout
socket.on('data', chunk => {
// TCP is a STREAM: chunks may split or merge messages.
// Frame your protocol (length prefix, delimiter, etc.)
console.log('received', chunk.length, 'bytes');
});
socket.on('timeout', () => socket.end());
socket.on('close', hadError => console.log('closed', hadError));
socket.on('drain', () => console.log('buffer drained'));
}).listen(5000);Schreiben & Half-close
socket.write respektiert Backpressure (liefert false bei vollem Buffer — auf 'drain' warten). end() halb-schließt: Es spült ausstehende Schreibvorgänge und sendet dann FIN, liest aber weiterhin vom Peer. destroy() killt den Socket sofort. remoteAddress/remotePort fürs Logging und Zugriffskontrolle nutzen. Pause/resume drosseln einen schnellen Sender.
const net = require('net');
net.createServer(socket => {
// write() returns false when the buffer is full (backpressure)
const ok = socket.write(bigPayload);
if (!ok) socket.once('drain', writeMore);
// half-close: send FIN, keep reading
socket.end(); // writes any pending data, then closes our side
// socket.end('final message\n'); // write + close
// fully destroy the socket immediately
socket.destroy();
// pause/resume reading
socket.pause();
socket.resume();
// address info
socket.remoteAddress; // '192.168.1.5'
socket.remotePort; // 54321
}).listen(5000);Server-Events & IPC
Ein net.Server emittiert 'connection' (pro Client), 'listening', 'error' (EADDRINUSE behandeln) und 'close'. listen kann einen Pfad für einen Unix-Socket (oder Named Pipe unter Windows) nehmen — schnelle, sichere lokale IPC zwischen Prozessen auf demselben Host. server.close() akzeptiert keine neuen Verbindungen mehr und wartet auf bestehende.
const net = require('net');
const server = net.createServer();
server.on('connection', socket => {}); // same as createServer cb
server.on('listening', () => console.log('bound'));
server.on('error', err => {
if (err.code === 'EADDRINUSE') console.error('port taken');
});
server.on('close', () => console.log('server closed'));
server.listen(5000);
// Unix domain socket / named pipe (fast local IPC)
server.listen('/tmp/app.sock');
// Windows: server.listen('\\\\.\\pipe\\app');
// stop accepting, close idle connections
server.close(() => console.log('all done'));
// get bound address
server.address(); // { port: 5000, family: 'IPv4', address: '::' }Timer & Utilities
Timer (setTimeout, setInterval)
setTimeout läuft einmal nach einer Verzögerung, setInterval wiederholt. setImmediate läuft nach I/O-Events im selben Loop-Durchlauf. queueMicrotask läuft noch früher, direkt nach der aktuellen Operation. Die Reihenfolge innerhalb eines Durchlaufs: erst Microtasks, dann Timer, dann I/O, dann setImmediate — nützlich zu wissen, wenn Folgearbeit geplant wird.
// run once after a delay (ms)
const t = setTimeout(() => console.log('hi'), 1000);
// run repeatedly every interval
const i = setInterval(() => console.log('tick'), 2000);
// run right after the current event loop turn
setImmediate(() => console.log('immediate'));
// run before the next event loop turn (microtask)
queueMicrotask(() => console.log('microtask'));
// order inside one loop:
// microtasks -> timers -> I/O -> check (setImmediate)Timer löschen & ref
Jeder Timer hat eine passende clear-Funktion. unref() markiert einen Timer als 'Prozess nicht am Leben halten' — bleiben nur unref'd-Timer, verlässt Node den Prozess (praktisch für periodisches Aufräumen, das den Prozess nicht festhalten soll). ref() dreht es zurück. Zusätzliche Argumente nach der Verzögerung werden an den Callback weitergereicht und ersparen eine extra Arrow-Funktion.
const t = setTimeout(() => {}, 1000);
clearTimeout(t); // cancel
const i = setInterval(() => {}, 1000);
clearInterval(i);
const imm = setImmediate(() => {});
clearImmediate(imm);
// keep the event loop alive?
// timers do by default; unref() lets the process exit if
// only this timer is pending
const timer = setInterval(() => {}, 1000);
timer.unref(); // won't keep Node alive
timer.ref(); // keep alive again
// pass args to the callback
setTimeout((a, b) => console.log(a, b), 500, 'x', 'y');util.inspect & format
util.format baut Strings mit printf-artigen Platzhaltern (%s %d %j %o %O %%). util.inspect rendert jedes Objekt — mit { depth: null, colors: true } für einen vollen farbigen Dump, nützlich in Logs. util.deprecate umhüllt eine Funktion, um beim Aufruf eine DeprecationWarning zu emittieren (mit --trace-deprecation sichtbar).
const util = require('util');
// format like printf
util.format('%s:%d', 'port', 3000); // 'port:3000'
util.format('%j', { a: 1 }); // JSON
// deep inspect an object (what console.dir uses)
util.inspect(obj, { depth: null, colors: true, compact: false });
// pretty-print a function (its source)
util.inspect(function f() { return 1; });
// deprecate an API with a warning
const oldFn = util.deprecate(
() => doThingOldWay(),
'oldFn() is deprecated, use newFn() instead'
);util.promisify
util.promisify umhüllt eine error-first-Callback-Funktion in eine, die ein Promise zurückgibt — die Brücke von Legacy-Callback-APIs zu async/await. Viele Kernmodule liefern inzwischen native Promise-Versionen (fs/promises), die zu bevorzugen sind, aber promisify rettet weiterhin Drittanbieter-Callback-APIs. Eine Funktion kann [util.promisify.custom] definieren, um die Konvertierung zu steuern.
const util = require('util');
const fs = require('fs');
// turn an error-first callback fn into a promise fn
const readFile = util.promisify(fs.readFile);
const text = await readFile('data.txt', 'utf8');
// works on custom functions too
function delay(ms, cb) { setTimeout(() => cb(null, ms), ms); }
const delayP = util.promisify(delay);
await delayP(100);
// custom promisify symbol (controls the promise behavior)
// const { promisify } = util;
// obj[util.promisify.custom] = () => Promise.resolve(42);
// many core modules ship promise versions directly:
// require('fs/promises'), require('dns/promises')util types & callbackify
util.types bietet zuverlässige Typchecks (isPromise, isAsyncFunction, isRegExp, isMap), die Cross-Realm- und Subclass-Randfälle besser überstehen als instanceof. util.callbackify kehrt promisify um — nützlich, wenn du eine promise-basierte Funktion einer Callback-API exponieren musst. util.MIMEType (Node 19+) parst und manipuliert MIME-Typen.
const util = require('util');
// type checks
util.isPromise(Promise.resolve()); // true
util.isFunction(() => {}); // true
util.types.isMap(new Map()); // true
util.types.isAsyncFunction(async () => {}); // true
util.types.isRegExp(/x/); // true
// reverse of promisify: promise -> error-first callback
const readFileCb = util.callbackify(require('fs/promises').readFile);
readFileCb('x.txt', 'utf8', (err, data) => {
if (err) console.error(err);
else console.log(data);
});
// MIME type utilities (Node 19+)
util.MIMEType.parse('text/html; charset=utf-8');nextTick vs. setImmediate
process.nextTick läuft direkt nach der aktuellen synchronen Operation, VOR I/O — rekursives nextTick kann I/O also unbegrenzt verhungern lassen (die Loop schreitet nie voran). setImmediate läuft nach I/O, in der 'check'-Phase. Um der Event-Loop nachzugeben und ausstehendes I/O sich zu erfüllen zu lassen, setImmediate bevorzugen; nextTick fürs Aufräumen reservieren, das vor jedem I/O-Callback passieren muss.
// process.nextTick: runs BEFORE I/O, after the current op
process.nextTick(() => console.log('tick'));
// setImmediate: runs AFTER I/O events, in the 'check' phase
setImmediate(() => console.log('immediate'));
// setTimeout(0): runs in the timers phase, after nextTick
setTimeout(() => console.log('timeout'), 0);
// typical order in one loop turn:
// 1. current sync code
// 2. nextTick callbacks (can starve I/O!)
// 3. timers
// 4. I/O callbacks
// 5. setImmediate
// prefer setImmediate to yield to I/O; use nextTick for
// immediate post-sync cleanupVerwandte Node.js-Snippets
Copy-paste ready code for common tasks.
fs Module
Read, write, and watch files with promises and callbacks.
HTTP Server
Build an HTTP server with the http module and routing.
Streams
Pipe, transform, and consume streams efficiently.
EventEmitter
Emit and listen for custom events.
path Module
Join, resolve, and parse file paths cross-platform.
Buffers
Work with binary data using Buffer and TypedArrays.
Child Process
Spawn, exec, and fork external processes.
Async Patterns
Run promises in parallel, sequentially, and with limits.
Was this helpful?