REPL

    By executing without any arguments from the command-line you will be
    dropped into the REPL. It has simplistic emacs line-editing.

    1. mjr:~$ node
    2. Type '.help' for options.
    3. > a = [ 1, 2, 3];
    4. [ 1, 2, 3 ]
    5. > a.forEach(function (v) {
    6. ...   console.log(v);
    7. ...   });
    8. 1
    9. 2
    10. 3

    For advanced line-editors, start node with the environmental variable
    NODE_NO_READLINE=1. This will start the main and debugger REPL in canonical
    terminal settings which will allow you to use with rlwrap.

    For example, you could add this to your bashrc file:

    1. alias node="env NODE_NO_READLINE=1 rlwrap node"

    Returns and starts a REPLServer instance, that inherits from
    [Readline Interface][]. Accepts an “options” Object that takes
    the following values:

    • prompt - the prompt and stream for all I/O. Defaults to >.

    • input - the readable stream to listen to. Defaults to process.stdin.

    • output - the writable stream to write readline data to. Defaults to
      process.stdout.

    • terminal - pass true if the stream should be treated like a TTY, and
      have ANSI/VT100 escape codes written to it. Defaults to checking isTTY
      on the output stream upon instantiation.

    • eval - function that will be used to eval each given line. Defaults to
      an async wrapper for eval(). See below for an example of a custom eval.

    • useColors - a boolean which specifies whether or not the writer function
      should output colors. If a different writer function is set then this does
      nothing. Defaults to the repl’s terminal value.

    • ignoreUndefined - if set to true, then the repl will not output the
      return value of command if it’s . Defaults to false.

    • writer - the function to invoke for each command that gets evaluated which
      returns the formatting (including coloring) to display. Defaults to
      util.inspect.

    You can use your own eval function if it has following signature:

    Multiple REPLs may be started against the same running instance of node. Each
    will share the same global object but will have unique I/O.

    Here is an example that starts a REPL on stdin, a Unix socket, and a TCP socket:

    1. var net = require("net"),
    3. connections = 0;
    5. repl.start({
    6.   prompt: "node via stdin> ",
    7.   input: process.stdin,
    8.   output: process.stdout
    9. });
    11. net.createServer(function (socket) {
    12.   connections += 1;
    13.   repl.start({
    14.     prompt: "node via Unix socket> ",
    15.     input: socket,
    16.     output: socket
    17.   }).on('exit', function() {
    18.     socket.end();
    19.   })
    20. }).listen("/tmp/node-repl-sock");
    22. net.createServer(function (socket) {
    23.   connections += 1;
    24.   repl.start({
    25.     prompt: "node via TCP socket> ",
    26.     input: socket,
    27.   }).on('exit', function() {
    28.     socket.end();
    29.   });
    30. }).listen(5001);

    Running this program from the command line will start a REPL on stdin. Other
    REPL clients may connect through the Unix socket or TCP socket. telnet is useful
    for connecting to TCP sockets, and socat can be used to connect to both Unix and
    TCP sockets.

    By starting a REPL from a Unix socket-based server instead of stdin, you can
    connect to a long-running node process without restarting it.

    For an example of running a “full-featured” (terminal) REPL over
    a and net.Socket instance, see: https://gist.github.com/2209310

    For an example of running a REPL instance over curl(1),
    see:

    function () {}

    Example of listening for exit:

    1. r.on('exit', function () {
    2.   console.log('Got "exit" event from repl!');
    3.   process.exit();
    4. });

    Event: ‘reset’

    function (context) {}

    Emitted when the REPL’s context is reset. This happens when you type .clear.
    If you start the repl with { useGlobal: true } then this event will never
    be emitted.

    Example of listening for reset:

    REPL Features

    Inside the REPL, Control+D will exit. Multi-line expressions can be input.
    Tab completion is supported for both global and local variables.

    The special variable _ (underscore) contains the result of the last expression.

    1. > [ "a", "b", "c" ]
    2. [ 'a', 'b', 'c' ]
    3. > _.length
    4. 3
    5. > _ += 1
    6. 4

    The REPL provides access to any variables in the global scope. You can expose
    a variable to the REPL explicitly by assigning it to the context object
    associated with each REPLServer. For example:

    1. // repl_test.js
    2. var repl = require("repl"),
    3.     msg = "message";
    5. repl.start("> ").context.m = msg;

    Things in the context object appear as local within the REPL:

    There are a few special REPL commands:

    • .break - While inputting a multi-line expression, sometimes you get lost
      or just don’t care about completing it. .break will start over.
    • .clear - Resets the context object to an empty object and clears any
      multi-line expression.
    • .exit - Close the I/O stream, which will cause the REPL to exit.
    • .help - Show this list of special commands.
    • .save - Save the current REPL session to a file
    • .load - Load a file into the current REPL session.

    The following key combinations in the REPL have these special effects:

    • - Similar to the .exit keyword.