REPL

[Stable: 2 - Stabil]

Stable: 2 Stabilität: 2 - Stabil

Quellcode: lib/repl.js

Das node:repl-Modul stellt eine Read-Eval-Print-Loop (REPL)-Implementierung bereit, die sowohl als eigenständiges Programm als auch in anderen Anwendungen verwendet werden kann. Der Zugriff erfolgt mit:

ESM

import repl from 'node:repl'

CJS

const repl = require('node:repl')

Design und Funktionen

Das node:repl-Modul exportiert die Klasse repl.REPLServer. Während der Ausführung akzeptieren Instanzen von repl.REPLServer einzelne Zeilen der Benutzereingabe, werten diese gemäß einer benutzerdefinierten Auswertungsfunktion aus und geben dann das Ergebnis aus. Eingabe und Ausgabe können von stdin bzw. stdout stammen oder mit einem beliebigen Node.js-Stream verbunden sein.

Instanzen von repl.REPLServer unterstützen die automatische Vervollständigung von Eingaben, die Vervollständigungsvorschau, eine einfache Zeilenbearbeitung im Emacs-Stil, mehrzeilige Eingaben, die ZSH-ähnliche Rückwärtssuche, die ZSH-ähnliche Substring-basierte Verlaufssuche, die ANSI-formatierte Ausgabe, das Speichern und Wiederherstellen des aktuellen REPL-Sitzungsstatus, die Fehlerbehebung und anpassbare Auswertungsfunktionen. Terminals, die keine ANSI-Stile und Emacs-artige Zeilenbearbeitung unterstützen, greifen automatisch auf einen eingeschränkten Funktionsumfang zurück.

Befehle und Sondertasten

Die folgenden Sonderbefehle werden von allen REPL-Instanzen unterstützt:

• .break: Wenn Sie sich in der Eingabe eines mehrzeiligen Ausdrucks befinden, geben Sie den Befehl .break ein (oder drücken Sie +), um die weitere Eingabe oder Verarbeitung dieses Ausdrucks abzubrechen.
• .clear: Setzt den REPL context auf ein leeres Objekt zurück und löscht alle mehrzeiligen Ausdrücke, die gerade eingegeben werden.
• .exit: Schließt den I/O-Stream, wodurch die REPL beendet wird.
• .help: Zeigt diese Liste von Sonderbefehlen an.
• .save: Speichert die aktuelle REPL-Sitzung in einer Datei: \> .save ./datei/zum/speichern.js
• .load: Lädt eine Datei in die aktuelle REPL-Sitzung. \> .load ./datei/zum/laden.js
• .editor: Ruft den Editormodus auf (+ zum Beenden, + zum Abbrechen).

> .editor
// Editor-Modus wird aufgerufen (^D zum Beenden, ^C zum Abbrechen)
function welcome(name) {
  return `Hallo ${name}!`;
}

welcome('Node.js Benutzer');

// ^D
'Hallo Node.js Benutzer!'
>

Die folgenden Tastenkombinationen in der REPL haben diese Sonderwirkungen:

• +: Wenn einmal gedrückt, hat es die gleiche Wirkung wie der Befehl .break. Wenn zweimal in einer leeren Zeile gedrückt, hat es die gleiche Wirkung wie der Befehl .exit.
• +: Hat die gleiche Wirkung wie der Befehl .exit.
• : Wenn in einer leeren Zeile gedrückt, werden globale und lokale (Scope-)Variablen angezeigt. Wenn während der Eingabe anderer Eingaben gedrückt, werden relevante Autovervollständigungsoptionen angezeigt.

Informationen zu Tastenkombinationen für die Rückwärtssuche finden Sie unter reverse-i-search. Alle anderen Tastenkombinationen finden Sie unter TTY-Tastenkombinationen.

Standardauswertung

Standardmäßig verwenden alle Instanzen von repl.REPLServer eine Auswertungsfunktion, die JavaScript-Ausdrücke auswertet und Zugriff auf die integrierten Node.js-Module bietet. Dieses Standardverhalten kann überschrieben werden, indem eine alternative Auswertungsfunktion übergeben wird, wenn die repl.REPLServer-Instanz erstellt wird.

JavaScript-Ausdrücke

Der Standardauswerter unterstützt die direkte Auswertung von JavaScript-Ausdrücken:

> 1 + 1
2
> const m = 2
undefined
> m + 1
3

Sofern nicht anders innerhalb von Blöcken oder Funktionen abgegrenzt, werden Variablen, die entweder implizit oder mit den Schlüsselwörtern const, let oder var deklariert werden, im globalen Gültigkeitsbereich deklariert.

Globaler und lokaler Gültigkeitsbereich

Der Standardauswerter bietet Zugriff auf alle Variablen, die im globalen Gültigkeitsbereich existieren. Es ist möglich, eine Variable der REPL explizit zugänglich zu machen, indem sie dem context-Objekt zugewiesen wird, das mit jedem REPLServer verbunden ist:

ESM

import repl from 'node:repl'
const msg = 'message'

repl.start('> ').context.m = msg

CJS

const repl = require('node:repl')
const msg = 'message'

repl.start('> ').context.m = msg

Eigenschaften im context-Objekt erscheinen innerhalb der REPL als lokal:

$ node repl_test.js
> m
'message'

Kontexteigenschaften sind standardmäßig nicht schreibgeschützt. Um schreibgeschützte globale Variablen anzugeben, müssen Kontexteigenschaften mit Object.defineProperty() definiert werden:

ESM

import repl from 'node:repl'
const msg = 'message'

const r = repl.start('> ')
Object.defineProperty(r.context, 'm', {
  configurable: false,
  enumerable: true,
  value: msg,
})

CJS

const repl = require('node:repl')
const msg = 'message'

const r = repl.start('> ')
Object.defineProperty(r.context, 'm', {
  configurable: false,
  enumerable: true,
  value: msg,
})

Zugriff auf Kernmodule von Node.js

Der Standardauswerter lädt automatisch die Kernmodule von Node.js in die REPL-Umgebung, wenn sie verwendet werden. Wenn beispielsweise nicht anders als globale oder lokale Variable deklariert, wird die Eingabe fs bei Bedarf als global.fs = require('node:fs') ausgewertet.

> fs.createReadStream('./some/file');

Globale nicht abgefangene Ausnahmen

[Verlauf]

Version	Änderungen
v12.3.0	Das Ereignis 'uncaughtException' wird von nun an ausgelöst, wenn die REPL als eigenständiges Programm verwendet wird.

Die REPL verwendet das domain-Modul, um alle nicht abgefangenen Ausnahmen für diese REPL-Sitzung abzufangen.

Diese Verwendung des domain-Moduls in der REPL hat folgende Nebeneffekte:

• Nicht abgefangene Ausnahmen geben das Ereignis 'uncaughtException' nur in der eigenständigen REPL aus. Das Hinzufügen eines Listeners für dieses Ereignis in einer REPL innerhalb eines anderen Node.js-Programms führt zu ERR_INVALID_REPL_INPUT.
• Der Versuch, process.setUncaughtExceptionCaptureCallback() zu verwenden, wirft einen ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE-Fehler.

Zuweisung der _ (Unterstrich) Variable

[Verlauf]

Version	Änderungen
v9.8.0	_error-Unterstützung hinzugefügt.

Der Standard-Evaluator weist standardmäßig das Ergebnis des zuletzt ausgewerteten Ausdrucks der speziellen Variable _ (Unterstrich) zu. Das explizite Setzen von _ auf einen Wert deaktiviert dieses Verhalten.

> [ 'a', 'b', 'c' ]
[ 'a', 'b', 'c' ]
> _.length
3
> _ += 1
Die Ausdruckszuweisung zu _ ist jetzt deaktiviert.
4
> 1 + 1
2
> _
4

Ebenso verweist _error auf den zuletzt gesehenen Fehler, falls es einen gab. Das explizite Setzen von _error auf einen Wert deaktiviert dieses Verhalten.

> throw new Error('foo');
Nicht abgefangener Fehler: foo
> _error.message
'foo'

await-Schlüsselwort

Die Unterstützung für das await-Schlüsselwort ist auf der obersten Ebene aktiviert.

> await Promise.resolve(123)
123
> await Promise.reject(new Error('REPL await'))
Nicht abgefangener Fehler: REPL await
    at REPL2:1:54
> const timeout = util.promisify(setTimeout);
undefined
> const old = Date.now(); await timeout(1000); console.log(Date.now() - old);
1002
undefined

Eine bekannte Einschränkung bei der Verwendung des await-Schlüsselworts in der REPL ist, dass es den lexikalischen Gültigkeitsbereich der Schlüsselwörter const und let ungültig macht.

Zum Beispiel:

> const m = await Promise.resolve(123)
undefined
> m
123
> const m = await Promise.resolve(234)
undefined
> m
234

--no-experimental-repl-await soll Top-Level-Await in REPL deaktivieren.

Rückwärts-i-Suche

Hinzugefügt in: v13.6.0, v12.17.0

Die REPL unterstützt eine bidirektionale Rückwärts-i-Suche ähnlich wie ZSH. Sie wird mit + ausgelöst, um rückwärts zu suchen, und mit +, um vorwärts zu suchen.

Doppelte Einträge in der History werden übersprungen.

Einträge werden akzeptiert, sobald eine beliebige Taste gedrückt wird, die nicht mit der Rückwärtssuche übereinstimmt. Das Abbrechen ist durch Drücken von oder + möglich.

Das Ändern der Richtung sucht sofort nach dem nächsten Eintrag in der erwarteten Richtung von der aktuellen Position aus.

Benutzerdefinierte Auswertungsfunktionen

Wenn ein neuer repl.REPLServer erstellt wird, kann eine benutzerdefinierte Auswertungsfunktion bereitgestellt werden. Dies kann beispielsweise verwendet werden, um vollständig angepasste REPL-Anwendungen zu implementieren.

Das Folgende veranschaulicht ein Beispiel für eine REPL, die eine gegebene Zahl quadriert:

ESM

import repl from 'node:repl'

function byThePowerOfTwo(number) {
  return number * number
}

function myEval(cmd, context, filename, callback) {
  callback(null, byThePowerOfTwo(cmd))
}

repl.start({ prompt: 'Geben Sie eine Zahl ein: ', eval: myEval })

CJS

const repl = require('node:repl')

function byThePowerOfTwo(number) {
  return number * number
}

function myEval(cmd, context, filename, callback) {
  callback(null, byThePowerOfTwo(cmd))
}

repl.start({ prompt: 'Geben Sie eine Zahl ein: ', eval: myEval })

Wiederherstellbare Fehler

Am REPL-Prompt sendet das Drücken von die aktuelle Eingabezeile an die eval-Funktion. Um mehrzeilige Eingaben zu unterstützen, kann die eval-Funktion eine Instanz von repl.Recoverable an die bereitgestellte Callback-Funktion zurückgeben:

function myEval(cmd, context, filename, callback) {
  let result
  try {
    result = vm.runInThisContext(cmd)
  } catch (e) {
    if (isRecoverableError(e)) {
      return callback(new repl.Recoverable(e))
    }
  }
  callback(null, result)
}

function isRecoverableError(error) {
  if (error.name === 'SyntaxError') {
    return /^(Unexpected end of input|Unexpected token)/.test(error.message)
  }
  return false
}

Anpassen der REPL-Ausgabe

Standardmäßig formatieren repl.REPLServer-Instanzen die Ausgabe mit der util.inspect()-Methode, bevor sie die Ausgabe in den bereitgestellten Writable-Stream schreiben (standardmäßig process.stdout). Die Inspektionsoption showProxy ist standardmäßig auf true gesetzt und die Option colors wird je nach der useColors-Option des REPL auf true gesetzt.

Die boolesche Option useColors kann bei der Konstruktion angegeben werden, um den Standard-Writer anzuweisen, ANSI-Style-Codes zu verwenden, um die Ausgabe der util.inspect()-Methode farbig zu gestalten.

Wenn der REPL als eigenständiges Programm ausgeführt wird, ist es auch möglich, die Inspektionsvorgaben des REPL von innerhalb des REPL zu ändern, indem die Eigenschaft inspect.replDefaults verwendet wird, die die defaultOptions von util.inspect() widerspiegelt.

> util.inspect.replDefaults.compact = false;
false
> [1]
[
  1
]
>

Um die Ausgabe einer repl.REPLServer-Instanz vollständig anzupassen, übergeben Sie eine neue Funktion für die writer-Option bei der Konstruktion. Das folgende Beispiel konvertiert beispielsweise einfach jeden Eingabetext in Großbuchstaben:

ESM

import repl from 'node:repl'

const r = repl.start({ prompt: '> ', eval: myEval, writer: myWriter })

function myEval(cmd, context, filename, callback) {
  callback(null, cmd)
}

function myWriter(output) {
  return output.toUpperCase()
}

CJS

const repl = require('node:repl')

const r = repl.start({ prompt: '> ', eval: myEval, writer: myWriter })

function myEval(cmd, context, filename, callback) {
  callback(null, cmd)
}

function myWriter(output) {
  return output.toUpperCase()
}

Klasse: REPLServer

Hinzugefügt in: v0.1.91

• options <Object> | <string> Siehe repl.start()
• Erweitert: <readline.Interface>

Instanzen von repl.REPLServer werden mit der Methode repl.start() oder direkt mit dem JavaScript-Schlüsselwort new erstellt.

ESM

import repl from 'node:repl'

const options = { useColors: true }

const firstInstance = repl.start(options)
const secondInstance = new repl.REPLServer(options)

CJS

const repl = require('node:repl')

const options = { useColors: true }

const firstInstance = repl.start(options)
const secondInstance = new repl.REPLServer(options)

Ereignis: 'exit'

Hinzugefügt in: v0.7.7

Das Ereignis 'exit' wird ausgelöst, wenn die REPL beendet wird, entweder durch Empfangen des Befehls .exit als Eingabe, durch Drücken von + zweimal, um SIGINT zu signalisieren, oder durch Drücken von +, um 'end' auf dem Eingabestream zu signalisieren. Der Listener-Callback wird ohne Argumente aufgerufen.

replServer.on('exit', () => {
  console.log('Ereignis "exit" von REPL erhalten!')
  process.exit()
})

Ereignis: 'reset'

Hinzugefügt in: v0.11.0

Das Ereignis 'reset' wird ausgelöst, wenn der Kontext der REPL zurückgesetzt wird. Dies geschieht immer dann, wenn der Befehl .clear als Eingabe empfangen wird, es sei denn, die REPL verwendet den Standard-Evaluator und die repl.REPLServer-Instanz wurde mit der Option useGlobal auf true gesetzt erstellt. Der Listener-Callback wird mit einer Referenz auf das context-Objekt als einzigem Argument aufgerufen.

Dies kann hauptsächlich verwendet werden, um den REPL-Kontext auf einen vordefinierten Zustand neu zu initialisieren:

ESM

import repl from 'node:repl'

function initializeContext(context) {
  context.m = 'test'
}

const r = repl.start({ prompt: '> ' })
initializeContext(r.context)

r.on('reset', initializeContext)

CJS

const repl = require('node:repl')

function initializeContext(context) {
  context.m = 'test'
}

const r = repl.start({ prompt: '> ' })
initializeContext(r.context)

r.on('reset', initializeContext)

Wenn dieser Code ausgeführt wird, kann die globale Variable 'm' geändert, aber dann mit dem Befehl .clear auf ihren Anfangswert zurückgesetzt werden:

$ ./node example.js
> m
'test'
> m = 1
1
> m
1
> .clear
Kontext wird gelöscht...
> m
'test'
>

replServer.defineCommand(keyword, cmd)

Hinzugefügt in: v0.3.0

• keyword <string> Das Befehlsschlüsselwort (ohne ein führendes . Zeichen).
• cmd <Object> | <Function> Die Funktion, die aufgerufen werden soll, wenn der Befehl verarbeitet wird.

Die Methode replServer.defineCommand() wird verwendet, um der REPL-Instanz neue .-präfixierte Befehle hinzuzufügen. Solche Befehle werden durch Eingabe eines . gefolgt vom keyword aufgerufen. Der cmd ist entweder eine Function oder ein Object mit den folgenden Eigenschaften:

• help <string> Hilfetext, der angezeigt wird, wenn .help eingegeben wird (Optional).
• action <Function> Die Funktion, die ausgeführt werden soll, optional mit einem einzelnen String-Argument.

Das folgende Beispiel zeigt zwei neue Befehle, die der REPL-Instanz hinzugefügt wurden:

ESM

import repl from 'node:repl'

const replServer = repl.start({ prompt: '> ' })
replServer.defineCommand('sayhello', {
  help: 'Sag hallo',
  action(name) {
    this.clearBufferedCommand()
    console.log(`Hallo, ${name}!`)
    this.displayPrompt()
  },
})
replServer.defineCommand('saybye', function saybye() {
  console.log('Auf Wiedersehen!')
  this.close()
})

CJS

const repl = require('node:repl')

const replServer = repl.start({ prompt: '> ' })
replServer.defineCommand('sayhello', {
  help: 'Sag hallo',
  action(name) {
    this.clearBufferedCommand()
    console.log(`Hallo, ${name}!`)
    this.displayPrompt()
  },
})
replServer.defineCommand('saybye', function saybye() {
  console.log('Auf Wiedersehen!')
  this.close()
})

Die neuen Befehle können dann innerhalb der REPL-Instanz verwendet werden:

> .sayhello Node.js Benutzer
Hallo, Node.js Benutzer!
> .saybye
Auf Wiedersehen!

replServer.displayPrompt([preserveCursor])

Hinzugefügt in: v0.1.91

• preserveCursor <boolean>

Die Methode replServer.displayPrompt() bereitet die REPL-Instanz für die Eingabe des Benutzers vor, indem sie die konfigurierte prompt in eine neue Zeile in der output druckt und die input fortsetzt, um neue Eingaben zu akzeptieren.

Wenn mehrzeilige Eingaben eingegeben werden, wird anstelle des 'prompt' ein Auslassungszeichen gedruckt.

Wenn preserveCursor true ist, wird die Cursorplatzierung nicht auf 0 zurückgesetzt.

Die Methode replServer.displayPrompt ist hauptsächlich dazu gedacht, innerhalb der Aktionsfunktion für Befehle aufgerufen zu werden, die mit der Methode replServer.defineCommand() registriert wurden.

replServer.clearBufferedCommand()

Hinzugefügt in: v9.0.0

Die Methode replServer.clearBufferedCommand() löscht alle Befehle, die zwischengespeichert, aber noch nicht ausgeführt wurden. Diese Methode ist hauptsächlich dazu gedacht, innerhalb der Aktionsfunktion für Befehle aufgerufen zu werden, die mit der Methode replServer.defineCommand() registriert wurden.

replServer.setupHistory(historyPath, callback)

Hinzugefügt in: v11.10.0

• historyPath <string> der Pfad zur History-Datei
• callback <Function> wird aufgerufen, wenn History-Schreibvorgänge bereit sind oder bei einem Fehler
  • err <Error>
  • repl <repl.REPLServer>

Initialisiert eine History-Protokolldatei für die REPL-Instanz. Beim Ausführen der Node.js-Binärdatei und der Verwendung der Befehlszeilen-REPL wird standardmäßig eine History-Datei initialisiert. Dies ist jedoch nicht der Fall, wenn eine REPL programmgesteuert erstellt wird. Verwenden Sie diese Methode, um eine History-Protokolldatei zu initialisieren, wenn Sie programmgesteuert mit REPL-Instanzen arbeiten.

repl.builtinModules

Hinzugefügt in: v14.5.0

• <string[]>

Eine Liste mit den Namen aller Node.js-Module, z. B. 'http'.

repl.start([options])

[History]

Version	Changes
v13.4.0, v12.17.0	Die Option preview ist jetzt verfügbar.
v12.0.0	Die Option terminal folgt nun in allen Fällen der Standardbeschreibung, und useColors überprüft hasColors(), falls verfügbar.
v10.0.0	Der REPL_MAGIC_MODE replMode wurde entfernt.
v6.3.0	Die Option breakEvalOnSigint wird jetzt unterstützt.
v5.8.0	Der Parameter options ist jetzt optional.
v0.1.91	Hinzugefügt in: v0.1.91

• options <Object> | <string>

  • prompt <string> Die Eingabeaufforderung, die angezeigt werden soll. Standard: '\> ' (mit einem nachgestellten Leerzeichen).
  • input <stream.Readable> Der Readable-Stream, aus dem die REPL-Eingabe gelesen wird. Standard: process.stdin.
  • output <stream.Writable> Der Writable-Stream, in den die REPL-Ausgabe geschrieben wird. Standard: process.stdout.
  • terminal <boolean> Wenn true, gibt an, dass die output als TTY-Terminal behandelt werden soll. Standard: Überprüfung des Werts der Eigenschaft isTTY des output-Streams bei der Instanziierung.
  • eval <Function> Die Funktion, die bei der Auswertung jeder eingegebenen Zeile verwendet werden soll. Standard: ein asynchroner Wrapper für die JavaScript-Funktion eval(). Eine eval-Funktion kann mit repl.Recoverable einen Fehler ausgeben, um anzuzeigen, dass die Eingabe unvollständig war und zusätzliche Zeilen abgefragt werden sollen.
  • useColors <boolean> Wenn true, gibt an, dass die Standardfunktion writer ANSI-Farbformatierungen in die REPL-Ausgabe aufnehmen soll. Wenn eine benutzerdefinierte Funktion writer bereitgestellt wird, hat dies keine Auswirkung. Standard: Überprüfung der Farbuntersützung im output-Stream, wenn der terminal-Wert der REPL-Instanz true ist.
  • useGlobal <boolean> Wenn true, gibt an, dass die Standardauswertungsfunktion das JavaScript global als Kontext verwendet, anstatt einen neuen separaten Kontext für die REPL-Instanz zu erstellen. Die Node-CLI-REPL setzt diesen Wert auf true. Standard: false.
  • ignoreUndefined <boolean> Wenn true, gibt an, dass der Standard-Writer den Rückgabewert eines Befehls nicht ausgibt, wenn er als undefined ausgewertet wird. Standard: false.
  • writer <Function> Die Funktion, die aufgerufen wird, um die Ausgabe jedes Befehls zu formatieren, bevor sie in output geschrieben wird. Standard: util.inspect().
  • completer <Function> Eine optionale Funktion, die für die benutzerdefinierte Tab-Auto-Vervollständigung verwendet wird. Siehe readline.InterfaceCompleter für ein Beispiel.
  • replMode <symbol> Ein Flag, das angibt, ob der Standard-Evaluator alle JavaScript-Befehle im strikten Modus oder im Standardmodus (slopy) ausführt. Akzeptable Werte sind:
    • repl.REPL_MODE_SLOPPY zum Auswerten von Ausdrücken im Slopy-Modus.
    • repl.REPL_MODE_STRICT zum Auswerten von Ausdrücken im strikten Modus. Dies entspricht dem Voranstellen von 'use strict' vor jeder Repl-Anweisung.
  • breakEvalOnSigint <boolean> Stoppt die Auswertung des aktuellen Codeabschnitts, wenn SIGINT empfangen wird, z. B. wenn + gedrückt wird. Dies kann nicht zusammen mit einer benutzerdefinierten Funktion eval verwendet werden. Standard: false.
  • preview <boolean> Definiert, ob die REPL Autovervollständigungs- und Ausgabevorschauen druckt oder nicht. Standard: true mit der Standard-Eval-Funktion und false, wenn eine benutzerdefinierte Eval-Funktion verwendet wird. Wenn terminal falsch ist, gibt es keine Vorschauen und der Wert von preview hat keine Auswirkungen.

• Gibt zurück: <repl.REPLServer>

Die Methode repl.start() erstellt und startet eine repl.REPLServer-Instanz.

Wenn options eine Zeichenfolge ist, gibt sie die Eingabeaufforderung an:

ESM

import repl from 'node:repl'

// eine Unix-ähnliche Eingabeaufforderung
repl.start('$ ')

CJS

const repl = require('node:repl')

// eine Unix-ähnliche Eingabeaufforderung
repl.start('$ ')

Die Node.js REPL

Node.js selbst verwendet das Modul node:repl, um eine eigene interaktive Schnittstelle zur Ausführung von JavaScript bereitzustellen. Diese kann verwendet werden, indem die Node.js-Binärdatei ohne Übergabe von Argumenten ausgeführt wird (oder indem das Argument -i übergeben wird):

$ node
> const a = [1, 2, 3];
undefined
> a
[ 1, 2, 3 ]
> a.forEach((v) => {
...   console.log(v);
...   });
1
2
3

Umgebungsvariablenoptionen

Verschiedene Verhaltensweisen der Node.js REPL können mithilfe der folgenden Umgebungsvariablen angepasst werden:

• NODE_REPL_HISTORY: Wenn ein gültiger Pfad angegeben wird, wird ein persistenter REPL-Verlauf in der angegebenen Datei gespeichert und nicht in .node_repl_history im Home-Verzeichnis des Benutzers. Wenn dieser Wert auf '' (eine leere Zeichenkette) gesetzt wird, wird der persistente REPL-Verlauf deaktiviert. Leerzeichen werden aus dem Wert entfernt. Auf Windows-Plattformen sind Umgebungsvariablen mit leeren Werten ungültig, daher setzen Sie diese Variable auf ein oder mehrere Leerzeichen, um den persistenten REPL-Verlauf zu deaktivieren.
• NODE_REPL_HISTORY_SIZE: Steuert, wie viele Zeilen des Verlaufs gespeichert werden, falls ein Verlauf verfügbar ist. Muss eine positive Zahl sein. Standard: 1000.
• NODE_REPL_MODE: Kann entweder 'sloppy' oder 'strict' sein. Standard: 'sloppy', was es erlaubt, Code im nicht-strikten Modus auszuführen.

Persistenter Verlauf

Standardmäßig speichert die Node.js REPL den Verlauf zwischen node-REPL-Sitzungen, indem Eingaben in einer Datei namens .node_repl_history im Home-Verzeichnis des Benutzers gespeichert werden. Dies kann deaktiviert werden, indem die Umgebungsvariable NODE_REPL_HISTORY='' gesetzt wird.

Verwenden der Node.js REPL mit erweiterten Zeilen-Editoren

Für erweiterte Zeilen-Editoren starten Sie Node.js mit der Umgebungsvariablen NODE_NO_READLINE=1. Dadurch werden die Haupt- und Debugger-REPL in kanonischen Terminaleinstellungen gestartet, was die Verwendung mit rlwrap ermöglicht.

Zum Beispiel kann Folgendes zu einer .bashrc-Datei hinzugefügt werden:

alias node="env NODE_NO_READLINE=1 rlwrap node"

Starten mehrerer REPL-Instanzen gegen eine einzelne laufende Instanz

Es ist möglich, mehrere REPL-Instanzen gegen eine einzelne laufende Instanz von Node.js zu erstellen und auszuführen, die sich ein einzelnes global-Objekt teilen, aber separate I/O-Schnittstellen haben.

Das folgende Beispiel bietet beispielsweise separate REPLs über stdin, einen Unix-Socket und einen TCP-Socket:

ESM

import net from 'node:net'
import repl from 'node:repl'
import process from 'node:process'

let connections = 0

repl.start({
  prompt: 'Node.js via stdin> ',
  input: process.stdin,
  output: process.stdout,
})

net
  .createServer(socket => {
    connections += 1
    repl
      .start({
        prompt: 'Node.js via Unix socket> ',
        input: socket,
        output: socket,
      })
      .on('exit', () => {
        socket.end()
      })
  })
  .listen('/tmp/node-repl-sock')

net
  .createServer(socket => {
    connections += 1
    repl
      .start({
        prompt: 'Node.js via TCP socket> ',
        input: socket,
        output: socket,
      })
      .on('exit', () => {
        socket.end()
      })
  })
  .listen(5001)

CJS

const net = require('node:net')
const repl = require('node:repl')
let connections = 0

repl.start({
  prompt: 'Node.js via stdin> ',
  input: process.stdin,
  output: process.stdout,
})

net
  .createServer(socket => {
    connections += 1
    repl
      .start({
        prompt: 'Node.js via Unix socket> ',
        input: socket,
        output: socket,
      })
      .on('exit', () => {
        socket.end()
      })
  })
  .listen('/tmp/node-repl-sock')

net
  .createServer(socket => {
    connections += 1
    repl
      .start({
        prompt: 'Node.js via TCP socket> ',
        input: socket,
        output: socket,
      })
      .on('exit', () => {
        socket.end()
      })
  })
  .listen(5001)

Wenn diese Anwendung von der Befehlszeile aus gestartet wird, wird eine REPL über stdin gestartet. Andere REPL-Clients können sich über den Unix-Socket oder den TCP-Socket verbinden. telnet ist zum Beispiel nützlich, um sich mit TCP-Sockets zu verbinden, während socat verwendet werden kann, um sich sowohl mit Unix- als auch mit TCP-Sockets zu verbinden.

Indem eine REPL von einem Unix-Socket-basierten Server anstelle von stdin gestartet wird, ist es möglich, sich mit einem lange laufenden Node.js-Prozess zu verbinden, ohne ihn neu zu starten.

Ein Beispiel für das Ausführen einer "voll ausgestatteten" (terminal) REPL über eine net.Server- und net.Socket-Instanz finden Sie unter: https://gist.github.com/TooTallNate/2209310.

Ein Beispiel für das Ausführen einer REPL-Instanz über curl(1) finden Sie unter: https://gist.github.com/TooTallNate/2053342.

Dieses Beispiel dient ausschließlich zu Schulungszwecken, um zu demonstrieren, wie Node.js-REPLs mit verschiedenen I/O-Streams gestartet werden können. Es sollte nicht in Produktionsumgebungen oder in einem Kontext verwendet werden, in dem Sicherheit ohne zusätzliche Schutzmaßnahmen eine Rolle spielt. Wenn Sie REPLs in einer realen Anwendung implementieren müssen, sollten Sie alternative Ansätze in Betracht ziehen, die diese Risiken mindern, wie z. B. die Verwendung sicherer Eingabemechanismen und die Vermeidung offener Netzwerkschnittstellen.