# node — Die Node.js-Runtime auf der Kommandozeile

> Die Node.js-Runtime auf der Kommandozeile — Skripte ausführen, REPL starten, Apps debuggen, Flags setzen und die JavaScript-Umgebung verwalten.

Source: https://www.jpkc.com/db/cheatsheets/build-languages/node/

<!-- PROSE:intro -->
`node` ist der Kommandozeilen-Einstieg zu Node.js, der serverseitigen JavaScript-Runtime auf Basis von Googles V8-Engine. Damit führst du Skriptdateien aus, wertest Code-Schnipsel direkt aus, öffnest eine interaktive REPL, hängst einen Debugger an und stellst die Runtime über Dutzende Flags und Umgebungsvariablen ein. Dieser Guide bündelt die Befehle für den Alltag — vom schnellen `node -e`-Einzeiler bis zu Heap-Profiling und nativer TypeScript-Unterstützung.
<!-- PROSE:intro:end -->

## Skripte ausführen

`node <script>` — Führt eine JavaScript-Datei aus.

```bash
node app.js
```

`node -e '<code>'` — Führt JavaScript direkt von der Kommandozeile aus.

```bash
node -e 'console.log(Math.random())'
```

`node -p '<expression>'` — Wertet einen Ausdruck aus und gibt das Ergebnis aus.

```bash
node -p 'process.versions.v8'
```

`node --input-type=module -e '<code>'` — Führt ES-Modul-Code von der Kommandozeile aus.

```bash
node --input-type=module -e 'import {readFile} from "fs/promises"; console.log("ok")'
```

`node - < <script>` — Liest ein Skript von stdin und führt es aus.

```bash
echo 'console.log(42)' | node -
```

## REPL & Interaktiv

`node` — Startet die interaktive REPL.

```bash
node
```

`node --experimental-repl-await` — Startet die REPL mit Unterstützung für Top-Level-await.

```bash
node --experimental-repl-await
```

`.help` — Zeigt die REPL-Befehle (innerhalb der REPL).

```bash
.help
```

`.load <file>` — Lädt eine Datei in die REPL-Sitzung.

```bash
.load utils.js
```

`.save <file>` — Speichert die REPL-Sitzung in einer Datei.

```bash
.save session.js
```

## Debugging

`node --inspect <script>` — Startet mit lauschendem Debugger (Verbindung über Chrome DevTools).

```bash
node --inspect app.js
```

`node --inspect-brk <script>` — Startet mit Debugger und hält vor der ersten Zeile an.

```bash
node --inspect-brk app.js
```

`node --inspect=<host>:<port> <script>` — Debuggt auf einem eigenen Host und Port.

```bash
node --inspect=0.0.0.0:9229 server.js
```

`node --prof <script>` — Erzeugt V8-CPU-Profiling-Ausgabe.

```bash
node --prof app.js
```

`node --prof-process <isolate-file>` — Wandelt V8-Profiling-Ausgabe in ein lesbares Format um.

```bash
node --prof-process isolate-0x*.log > profile.txt
```

## Umgebung & Konfiguration

`NODE_ENV=production node <script>` — Läuft mit einer bestimmten Umgebung.

```bash
NODE_ENV=production node server.js
```

`node --max-old-space-size=<MB> <script>` — Setzt die maximale Heap-Speichergröße.

```bash
node --max-old-space-size=4096 build.js
```

`node --env-file=<file> <script>` — Lädt Umgebungsvariablen aus einer Datei (Node 20.6+).

```bash
node --env-file=.env app.js
```

`node -r <module> <script>` — Lädt ein Modul vor dem Skript (Preload/Require).

```bash
node -r dotenv/config app.js
```

`node --experimental-vm-modules <script>` — Aktiviert die experimentelle Unterstützung für VM-Module.

```bash
node --experimental-vm-modules test.js
```

## ES-Module & TypeScript

`node --loader ts-node/esm <script>` — Führt TypeScript-Dateien direkt mit ts-node aus.

```bash
node --loader ts-node/esm app.ts
```

`node --experimental-strip-types <script>` — Führt TypeScript-Dateien nativ aus (Node 22.6+).

```bash
node --experimental-strip-types app.ts
```

`node --conditions <condition> <script>` — Setzt eigene Export-Bedingungen aus der package.json.

```bash
node --conditions development app.js
```

## Info & Diagnose

`node --version` — Zeigt die installierte Node.js-Version.

```bash
node --version
```

`node -p 'process.versions'` — Zeigt alle Versionen der Runtime-Komponenten (V8, OpenSSL usw.).

```bash
node -p 'process.versions'
```

`node -p 'process.arch'` — Zeigt die CPU-Architektur.

```bash
node -p 'process.arch'
```

`node --v8-options | grep <flag>` — Durchsucht die Flags der V8-Engine.

```bash
node --v8-options | grep harmony
```

`node --report-on-fatalerror <script>` — Erzeugt bei fatalen Fehlern einen Diagnosebericht.

```bash
node --report-on-fatalerror server.js
```

`node --heap-prof <script>` — Erzeugt Heap-Profiling-Daten.

```bash
node --heap-prof app.js
```

<!-- PROSE:outro -->
## Fazit

Die `node`-Binary ist weit mehr als ein Skript-Starter: Mit den richtigen Flags wird sie zum Debugger, Profiler, Speicher-Tuner oder sogar TypeScript-Runner. Greif zu `--inspect`, wenn etwas hakt, zu `--env-file`, um Geheimnisse aus dem Code herauszuhalten, und zu `node -p` für einen schnellen Blick in die Runtime. Behandle experimentelle Flags (`--experimental-*`) mit Vorsicht — sie können sich zwischen Releases ändern oder verschwinden, im Produktivbetrieb also besser meiden. `NODE_OPTIONS` ist praktisch, gilt aber für jeden Node-Prozess in der Shell, und denk daran: Ein fremdes Skript führt seinen Code mit deinen vollen Rechten aus — erst lesen, dann ausführen.

## Weiterführende Links

- [Node.js-Dokumentation](https://nodejs.org/docs/latest/api/) – offizielle API-Referenz für jedes eingebaute Modul (englisch)
- [Node.js lernen](https://nodejs.org/en/learn) – offizielle Anleitungen und Tutorials (englisch)
- [Command-line options](https://nodejs.org/api/cli.html) – vollständige Referenz aller CLI-Flags und Umgebungsvariablen (englisch)
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [artisan](https://www.jpkc.com/db/cheatsheets/build-languages/artisan/) – CLI des Laravel-PHP-Frameworks für Migrations, Tasks und Code-Generierung
- [cargo](https://www.jpkc.com/db/cheatsheets/build-languages/cargo/) – Paketmanager und Build-Tool der Programmiersprache Rust
- [composer](https://www.jpkc.com/db/cheatsheets/build-languages/composer/) – Abhängigkeitsverwaltung für PHP-Projekte