REPL

[Stable: 2 - Stable]

Code source : lib/repl.js

Le module node:repl fournit une implémentation Read-Eval-Print-Loop (REPL) qui est disponible à la fois en tant que programme autonome ou inclus dans d’autres applications. On y accède en utilisant :

ESMCJS

import repl from 'node:repl'

const repl = require('node:repl')

Conception et fonctionnalités

Le module node:repl exporte la classe repl.REPLServer. Pendant l’exécution, les instances de repl.REPLServer accepteront les lignes individuelles de saisie utilisateur, les évalueront en fonction d’une fonction d’évaluation définie par l’utilisateur, puis afficheront le résultat. L’entrée et la sortie peuvent provenir de stdin et stdout, respectivement, ou être connectées à n’importe quel flux Node.js.

Les instances de repl.REPLServer prennent en charge la saisie semi-automatique des entrées, l’aperçu de la saisie semi-automatique, l’édition de ligne simpliste de style Emacs, les entrées multilignes, la recherche inversée de style ZSH, la recherche d’historique basée sur les sous-chaînes de style ZSH, la sortie de style ANSI, l’enregistrement et la restauration de l’état de la session REPL actuelle, la récupération d’erreurs et des fonctions d’évaluation personnalisables. Les terminaux qui ne prennent pas en charge les styles ANSI et l’édition de ligne de style Emacs passent automatiquement à un ensemble de fonctionnalités limité.

Commandes et touches spéciales

Les commandes spéciales suivantes sont prises en charge par toutes les instances REPL :

.break : lors de la saisie d’une expression multiligne, entrez la commande .break (ou appuyez sur +) pour annuler la saisie ou le traitement de cette expression.
.clear : réinitialise le contexte REPL à un objet vide et efface toute expression multiligne en cours de saisie.
.exit : ferme le flux E/S, ce qui provoque la fermeture du REPL.
.help : affiche cette liste de commandes spéciales.
.save : enregistre la session REPL actuelle dans un fichier : \> .save ./file/to/save.js
.load : charge un fichier dans la session REPL actuelle. \> .load ./file/to/load.js
.editor : entre en mode éditeur (+ pour terminer, + pour annuler).

bash

> .editor
// Entrée en mode éditeur (^D pour terminer, ^C pour annuler)
function welcome(name) {
  return `Bonjour ${name} !`;
}

welcome('Utilisateur Node.js');

// ^D
'Bonjour Utilisateur Node.js !'
>

Les combinaisons de touches suivantes dans le REPL ont ces effets spéciaux :

+ : lorsqu’elle est appuyée une fois, a le même effet que la commande .break. Lorsqu’elle est appuyée deux fois sur une ligne vide, a le même effet que la commande .exit.
+ : a le même effet que la commande .exit.
: lorsqu’elle est appuyée sur une ligne vide, affiche les variables globales et locales (portée). Lorsqu’elle est appuyée lors de la saisie d’autres données, affiche les options de saisie semi-automatique pertinentes.

Pour les combinaisons de touches relatives à la recherche inversée, consultez reverse-i-search. Pour toutes les autres combinaisons de touches, consultez Combinaisons de touches TTY.

Évaluation par défaut

Par défaut, toutes les instances de repl.REPLServer utilisent une fonction d'évaluation qui évalue les expressions JavaScript et donne accès aux modules intégrés de Node.js. Ce comportement par défaut peut être modifié en passant une fonction d'évaluation alternative lors de la création de l'instance repl.REPLServer.

Expressions JavaScript

L'évaluateur par défaut prend en charge l'évaluation directe des expressions JavaScript :

bash

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

Sauf si elles sont délimitées dans des blocs ou des fonctions, les variables déclarées implicitement ou à l'aide des mots-clés const, let ou var sont déclarées dans la portée globale.

Portée globale et locale

L'évaluateur par défaut donne accès à toutes les variables qui existent dans la portée globale. Il est possible d'exposer explicitement une variable au REPL en l'affectant à l'objet context associé à chaque REPLServer :

ESMCJS

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

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

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

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

Les propriétés de l'objet context apparaissent comme locales dans le REPL :

bash

$ node repl_test.js
> m
'message'

Les propriétés du contexte ne sont pas en lecture seule par défaut. Pour spécifier des variables globales en lecture seule, les propriétés du contexte doivent être définies à l'aide de Object.defineProperty() :

ESMCJS

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

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

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

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

Accès aux modules principaux de Node.js

L'évaluateur par défaut chargera automatiquement les modules principaux de Node.js dans l'environnement REPL lorsqu'il est utilisé. Par exemple, sauf indication contraire en tant que variable globale ou délimitée, l'entrée fs sera évaluée à la demande comme global.fs = require('node:fs').

bash

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

Exceptions globales non interceptées

[Historique]

Version	Modifications
v12.3.0	L'événement `'uncaughtException'` est désormais déclenché si le REPL est utilisé comme programme autonome.

Le REPL utilise le module domain pour intercepter toutes les exceptions non interceptées pour cette session REPL.

Cette utilisation du module domain dans le REPL a les effets secondaires suivants :

Les exceptions non interceptées n'émettent l'événement 'uncaughtException' que dans le REPL autonome. L'ajout d'un écouteur pour cet événement dans un REPL au sein d'un autre programme Node.js entraîne une erreur ERR_INVALID_REPL_INPUT.
Tenter d'utiliser process.setUncaughtExceptionCaptureCallback() lève une erreur ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE.

Affectation de la variable `_` (tiret bas)

[Historique]

Version	Modifications
v9.8.0	Ajout de la prise en charge de `_error`.

L'évaluateur par défaut attribuera, par défaut, le résultat de l'expression la plus récemment évaluée à la variable spéciale _ (tiret bas). Définir explicitement _ sur une valeur désactivera ce comportement.

bash

> [ 'a', 'b', 'c' ]
[ 'a', 'b', 'c' ]
> _.length
3
> _ += 1
L'affectation d'expression à _ est maintenant désactivée.
4
> 1 + 1
2
> _
4

De même, _error fera référence à la dernière erreur rencontrée, s'il y en a eu. Définir explicitement _error sur une valeur désactivera ce comportement.

bash

> throw new Error('foo');
Uncaught Error: foo
> _error.message
'foo'

Mot-clé `await`

La prise en charge du mot-clé await est activée au niveau supérieur.

bash

> await Promise.resolve(123)
123
> await Promise.reject(new Error('REPL await'))
Uncaught Error: 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

Une limitation connue de l'utilisation du mot-clé await dans le REPL est qu'il invalidera la portée lexicale des mots-clés const et let.

Par exemple :

bash

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

--no-experimental-repl-await désactivera l'await de niveau supérieur dans le REPL.

Recherche-i-inverse

Ajouté dans : v13.6.0, v12.17.0

Le REPL prend en charge la recherche-i-inverse bidirectionnelle similaire à ZSH. Elle est déclenchée avec + pour rechercher en arrière et + pour rechercher en avant.

Les entrées d'historique dupliquées seront ignorées.

Les entrées sont acceptées dès qu'une touche qui ne correspond pas à la recherche inverse est pressée. L'annulation est possible en appuyant sur ou +.

Changer la direction recherche immédiatement l'entrée suivante dans la direction attendue à partir de la position actuelle.

Fonctions d'évaluation personnalisées

Lorsqu'un nouveau repl.REPLServer est créé, une fonction d'évaluation personnalisée peut être fournie. Cela peut être utilisé, par exemple, pour mettre en œuvre des applications REPL entièrement personnalisées.

L'exemple suivant illustre un REPL qui met au carré un nombre donné :

ESMCJS

import repl from 'node:repl'

function byThePowerOfTwo(number) {
  return number * number
}

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

repl.start({ prompt: 'Entrez un nombre : ', eval: myEval })

const repl = require('node:repl')

function byThePowerOfTwo(number) {
  return number * number
}

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

repl.start({ prompt: 'Entrez un nombre : ', eval: myEval })

Erreurs récupérables

À l'invite du REPL, appuyer sur envoie la ligne d'entrée actuelle à la fonction eval. Afin de prendre en charge l'entrée multiligne, la fonction eval peut retourner une instance de repl.Recoverable à la fonction de rappel fournie :

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
}

Personnalisation de la sortie REPL

Par défaut, les instances repl.REPLServer formatent la sortie en utilisant la méthode util.inspect() avant d'écrire la sortie dans le flux Writable fourni (process.stdout par défaut). L'option d'inspection showProxy est définie sur true par défaut et l'option colors est définie sur true en fonction de l'option useColors du REPL.

L'option booléenne useColors peut être spécifiée lors de la construction pour indiquer à l'enregistreur par défaut d'utiliser les codes de style ANSI pour coloriser la sortie de la méthode util.inspect().

Si le REPL est exécuté en tant que programme autonome, il est également possible de modifier les paramètres par défaut d'inspection du REPL à partir du REPL en utilisant la propriété inspect.replDefaults qui reflète les defaultOptions de util.inspect().

bash

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

Pour personnaliser entièrement la sortie d'une instance repl.REPLServer, transmettez une nouvelle fonction pour l'option writer lors de la construction. L'exemple suivant, par exemple, convertit simplement tout texte saisi en majuscules :

ESMCJS

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()
}

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()
}

Classe : `REPLServer`

Ajouté dans : v0.1.91

options <Object> | <string> Voir repl.start()
Étend : <readline.Interface>

Les instances de repl.REPLServer sont créées à l'aide de la méthode repl.start() ou directement à l'aide du mot-clé JavaScript new.

ESMCJS

import repl from 'node:repl'

const options = { useColors: true }

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

const repl = require('node:repl')

const options = { useColors: true }

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

Événement : `'exit'`

Ajouté dans la version : v0.7.7

L’événement 'exit' est émis lorsque le REPL est quitté, soit en recevant la commande .exit en entrée, soit en appuyant deux fois sur + pour signaler SIGINT, soit en appuyant sur + pour signaler 'end' sur le flux d’entrée. La fonction de rappel de l’écouteur est invoquée sans aucun argument.

replServer.on('exit', () => {
  console.log('Événement "exit" reçu du repl !')
  process.exit()
})

Événement : `'reset'`

Ajouté dans la version : v0.11.0

L’événement 'reset' est émis lorsque le contexte du REPL est réinitialisé. Cela se produit chaque fois que la commande .clear est reçue en entrée, sauf si le REPL utilise l’évaluateur par défaut et que l’instance repl.REPLServer a été créée avec l’option useGlobal définie sur true. La fonction de rappel de l’écouteur sera appelée avec une référence à l’objet context comme seul argument.

Cela peut être utilisé principalement pour réinitialiser le contexte du REPL à un état prédéfini :

ESMCJS

import repl from 'node:repl'

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

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

r.on('reset', initializeContext)

const repl = require('node:repl')

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

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

r.on('reset', initializeContext)

Lorsque ce code est exécuté, la variable globale 'm' peut être modifiée, puis réinitialisée à sa valeur initiale à l’aide de la commande .clear :

bash

$ ./node example.js
> m
'test'
> m = 1
1
> m
1
> .clear
Effacement du contexte...
> m
'test'
>

`replServer.defineCommand(keyword, cmd)`

Ajouté dans la version : v0.3.0

keyword <string> Le mot-clé de la commande (sans caractère . de début).
cmd <Object> | <Function> La fonction à invoquer lorsque la commande est traitée.

La méthode replServer.defineCommand() est utilisée pour ajouter de nouvelles commandes préfixées par . à l’instance REPL. Ces commandes sont invoquées en saisissant un . suivi du keyword. L’argument cmd est soit une Function, soit un Object avec les propriétés suivantes :

help <string> Texte d’aide à afficher lorsque .help est saisi (facultatif).
action <Function> La fonction à exécuter, acceptant éventuellement un seul argument de type chaîne.

L’exemple suivant montre deux nouvelles commandes ajoutées à l’instance REPL :

ESMCJS

import repl from 'node:repl'

const replServer = repl.start({ prompt: '> ' })
replServer.defineCommand('sayhello', {
  help: 'Dire bonjour',
  action(name) {
    this.clearBufferedCommand()
    console.log(`Bonjour, ${name} !`)
    this.displayPrompt()
  },
})
replServer.defineCommand('saybye', function saybye() {
  console.log('Au revoir !')
  this.close()
})

const repl = require('node:repl')

const replServer = repl.start({ prompt: '> ' })
replServer.defineCommand('sayhello', {
  help: 'Dire bonjour',
  action(name) {
    this.clearBufferedCommand()
    console.log(`Bonjour, ${name} !`)
    this.displayPrompt()
  },
})
replServer.defineCommand('saybye', function saybye() {
  console.log('Au revoir !')
  this.close()
})

Les nouvelles commandes peuvent ensuite être utilisées à partir de l’instance REPL :

bash

> .sayhello Utilisateur de Node.js
Bonjour, Utilisateur de Node.js !
> .saybye
Au revoir !

`replServer.displayPrompt([preserveCursor])`

Ajouté dans : v0.1.91

preserveCursor <boolean>

La méthode replServer.displayPrompt() prépare l'instance REPL pour la saisie de l'utilisateur, en affichant l'invite configurée sur une nouvelle ligne dans la sortie et en reprenant l'entrée pour accepter de nouvelles saisies.

Lorsque la saisie multiligne est en cours, des points de suspension sont affichés plutôt que l'« invite ».

Lorsque preserveCursor est true, le positionnement du curseur ne sera pas réinitialisé à 0.

La méthode replServer.displayPrompt est principalement destinée à être appelée depuis la fonction d'action pour les commandes enregistrées à l'aide de la méthode replServer.defineCommand().

`replServer.clearBufferedCommand()`

Ajouté dans : v9.0.0

La méthode replServer.clearBufferedCommand() efface toute commande qui a été mise en mémoire tampon mais pas encore exécutée. Cette méthode est principalement destinée à être appelée depuis la fonction d'action pour les commandes enregistrées à l'aide de la méthode replServer.defineCommand().

`replServer.setupHistory(historyPath, callback)`

Ajouté dans : v11.10.0

historyPath <string> le chemin d'accès au fichier d'historique
callback <Function> appelée lorsque les écritures d'historique sont prêtes ou en cas d'erreur
- err <Error>
- repl <repl.REPLServer>

Initialise un fichier journal d'historique pour l'instance REPL. Lors de l'exécution du binaire Node.js et de l'utilisation du REPL en ligne de commande, un fichier d'historique est initialisé par défaut. Cependant, ce n'est pas le cas lors de la création d'un REPL par programmation. Utilisez cette méthode pour initialiser un fichier journal d'historique lorsque vous travaillez avec des instances REPL par programmation.

`repl.builtinModules`

Ajouté dans : v14.5.0

<string[]>

Une liste des noms de tous les modules Node.js, par exemple, 'http'.

`repl.start([options])`

[Historique]

Version	Modifications
v13.4.0, v12.17.0	L'option `preview` est désormais disponible.
v12.0.0	L'option `terminal` suit maintenant la description par défaut dans tous les cas et `useColors` vérifie `hasColors()` si disponible.
v10.0.0	Le `replMode` `REPL_MAGIC_MODE` a été supprimé.
v6.3.0	L'option `breakEvalOnSigint` est désormais prise en charge.
v5.8.0	Le paramètre `options` est désormais facultatif.
v0.1.91	Ajouté dans : v0.1.91

options <Object> | <string>
- prompt <string> L'invite d'entrée à afficher. Par défaut : '\> ' (avec un espace de fin).
- input <stream.Readable> Le flux Readable à partir duquel l'entrée REPL sera lue. Par défaut : process.stdin.
- output <stream.Writable> Le flux Writable vers lequel la sortie REPL sera écrite. Par défaut : process.stdout.
- terminal <boolean> Si true, spécifie que la output doit être traitée comme un terminal TTY. Par défaut : vérifie la valeur de la propriété isTTY sur le flux output lors de l'instanciation.
- eval <Function> La fonction à utiliser lors de l'évaluation de chaque ligne d'entrée donnée. Par défaut : un wrapper asynchrone pour la fonction JavaScript eval(). Une fonction eval peut générer une erreur avec repl.Recoverable pour indiquer que l'entrée était incomplète et inviter à des lignes supplémentaires.
- useColors <boolean> Si true, spécifie que la fonction writer par défaut doit inclure un style de couleur ANSI pour la sortie REPL. Si une fonction writer personnalisée est fournie, cela n'a aucun effet. Par défaut : vérifie la prise en charge des couleurs sur le flux output si la valeur terminal de l'instance REPL est true.
- useGlobal <boolean> Si true, spécifie que la fonction d'évaluation par défaut utilisera le global JavaScript comme contexte au lieu de créer un nouveau contexte distinct pour l'instance REPL. Le REPL de l'interface de ligne de commande node définit cette valeur sur true. Par défaut : false.
- ignoreUndefined <boolean> Si true, spécifie que l'enregistreur par défaut ne produira pas la valeur de retour d'une commande si elle est évaluée à undefined. Par défaut : false.
- writer <Function> La fonction à invoquer pour formater la sortie de chaque commande avant d'écrire dans output. Par défaut : util.inspect().
- completer <Function> Une fonction facultative utilisée pour l'auto-complétion personnalisée par tabulation. Voir readline.InterfaceCompleter pour un exemple.
- replMode <symbol> Un indicateur qui spécifie si l'évaluateur par défaut exécute toutes les commandes JavaScript en mode strict ou en mode par défaut (relâché). Les valeurs acceptables sont :
- repl.REPL_MODE_SLOPPY pour évaluer les expressions en mode relâché.
- repl.REPL_MODE_STRICT pour évaluer les expressions en mode strict. Cela équivaut à faire précéder chaque instruction repl de 'use strict'.
- breakEvalOnSigint <boolean> Arrête d'évaluer le morceau de code actuel lorsque SIGINT est reçu, par exemple lorsque + est pressé. Cela ne peut pas être utilisé avec une fonction eval personnalisée. Par défaut : false.
- preview <boolean> Définit si le repl affiche des aperçus d'autocomplétion et de sortie ou non. Par défaut : true avec la fonction d'évaluation par défaut et false si une fonction d'évaluation personnalisée est utilisée. Si terminal est faux, il n'y a pas d'aperçus et la valeur de preview n'a aucun effet.
Retourne : <repl.REPLServer>

La méthode repl.start() crée et démarre une instance repl.REPLServer.

Si options est une chaîne, elle spécifie l'invite d'entrée :

ESMCJS

import repl from 'node:repl'

// une invite de style Unix
repl.start('$ ')

const repl = require('node:repl')

// une invite de style Unix
repl.start('$ ')

Le REPL de Node.js

Node.js lui-même utilise le module node:repl pour fournir sa propre interface interactive pour exécuter JavaScript. Cela peut être utilisé en exécutant le binaire Node.js sans passer d'arguments (ou en passant l'argument -i) :

bash

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

Options des variables d'environnement

Divers comportements du REPL de Node.js peuvent être personnalisés à l'aide des variables d'environnement suivantes :

NODE_REPL_HISTORY : lorsqu'un chemin valide est donné, l'historique persistant du REPL sera enregistré dans le fichier spécifié plutôt que dans .node_repl_history dans le répertoire personnel de l'utilisateur. Définir cette valeur sur '' (une chaîne vide) désactivera l'historique persistant du REPL. Les espaces seront supprimés de la valeur. Sur les plateformes Windows, les variables d'environnement avec des valeurs vides ne sont pas valides, donc définissez cette variable sur un ou plusieurs espaces pour désactiver l'historique persistant du REPL.
NODE_REPL_HISTORY_SIZE : contrôle le nombre de lignes d'historique qui seront conservées si l'historique est disponible. Doit être un nombre positif. Par défaut : 1000.
NODE_REPL_MODE : peut être 'sloppy' ou 'strict'. Par défaut : 'sloppy', ce qui permettra d'exécuter du code en mode non strict.

Historique persistant

Par défaut, le REPL de Node.js conservera l'historique entre les sessions REPL node en enregistrant les entrées dans un fichier .node_repl_history situé dans le répertoire personnel de l'utilisateur. Cela peut être désactivé en définissant la variable d'environnement NODE_REPL_HISTORY=''.

Utilisation du REPL de Node.js avec des éditeurs de ligne avancés

Pour les éditeurs de ligne avancés, démarrez Node.js avec la variable d'environnement NODE_NO_READLINE=1. Cela démarrera le REPL principal et le débogueur dans les paramètres de terminal canoniques, ce qui permettra l'utilisation avec rlwrap.

Par exemple, ce qui suit peut être ajouté à un fichier .bashrc :

bash

alias node="env NODE_NO_READLINE=1 rlwrap node"

Démarrage de plusieurs instances REPL par rapport à une seule instance en cours d'exécution

Il est possible de créer et d'exécuter plusieurs instances REPL par rapport à une seule instance de Node.js en cours d'exécution qui partagent un seul objet global mais qui ont des interfaces d'E/S séparées.

L'exemple suivant, par exemple, fournit des REPL séparés sur stdin, un socket Unix et un socket TCP :

ESMCJS

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)

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)

L'exécution de cette application à partir de la ligne de commande démarrera un REPL sur stdin. D'autres clients REPL peuvent se connecter via le socket Unix ou le socket TCP. telnet, par exemple, est utile pour se connecter aux sockets TCP, tandis que socat peut être utilisé pour se connecter aux sockets Unix et TCP.

En démarrant un REPL à partir d'un serveur basé sur un socket Unix au lieu de stdin, il est possible de se connecter à un processus Node.js de longue durée sans le redémarrer.

Pour un exemple d'exécution d'un REPL « complet » (terminal) sur une instance net.Server et net.Socket, consultez : https://gist.github.com/TooTallNate/2209310.

Pour un exemple d'exécution d'une instance REPL sur curl(1), consultez : https://gist.github.com/TooTallNate/2053342.

Cet exemple est destiné uniquement à des fins éducatives pour montrer comment les REPL de Node.js peuvent être démarrés à l'aide de différents flux d'E/S. Il ne doit pas être utilisé dans des environnements de production ou dans tout contexte où la sécurité est une préoccupation sans mesures de protection supplémentaires. Si vous avez besoin de mettre en œuvre des REPL dans une application réelle, envisagez d'autres approches qui atténuent ces risques, telles que l'utilisation de mécanismes de saisie sécurisés et l'évitement des interfaces réseau ouvertes.

REPL ​

Conception et fonctionnalités ​

Commandes et touches spéciales ​

Évaluation par défaut ​

Expressions JavaScript ​

Portée globale et locale ​

Accès aux modules principaux de Node.js ​

Exceptions globales non interceptées ​

Affectation de la variable _ (tiret bas) ​

Mot-clé await ​

Recherche-i-inverse ​

Fonctions d'évaluation personnalisées ​

Erreurs récupérables ​

Personnalisation de la sortie REPL ​

Classe : REPLServer ​

Événement : 'exit' ​

Événement : 'reset' ​

replServer.defineCommand(keyword, cmd) ​

replServer.displayPrompt([preserveCursor]) ​

replServer.clearBufferedCommand() ​

replServer.setupHistory(historyPath, callback) ​

repl.builtinModules ​

repl.start([options]) ​

Le REPL de Node.js ​

Options des variables d'environnement ​

Historique persistant ​

Utilisation du REPL de Node.js avec des éditeurs de ligne avancés ​

Démarrage de plusieurs instances REPL par rapport à une seule instance en cours d'exécution ​

REPL

Conception et fonctionnalités

Commandes et touches spéciales

Évaluation par défaut

Expressions JavaScript

Portée globale et locale

Accès aux modules principaux de Node.js

Exceptions globales non interceptées

Affectation de la variable `_` (tiret bas)

Mot-clé `await`

Recherche-i-inverse

Fonctions d'évaluation personnalisées

Erreurs récupérables

Personnalisation de la sortie REPL

Classe : `REPLServer`

Événement : `'exit'`

Événement : `'reset'`

`replServer.defineCommand(keyword, cmd)`

`replServer.displayPrompt([preserveCursor])`

`replServer.clearBufferedCommand()`

`replServer.setupHistory(historyPath, callback)`

`repl.builtinModules`

`repl.start([options])`

Le REPL de Node.js

Options des variables d'environnement

Historique persistant

Utilisation du REPL de Node.js avec des éditeurs de ligne avancés

Démarrage de plusieurs instances REPL par rapport à une seule instance en cours d'exécution