readline

The node:readline module provides an interface for reading data from a Readable stream (such as process.stdin) one line at a time.

To use the promise-based APIs:

import * as readline from 'node:readline/promises';

To use the callback and sync APIs:

import * as readline from 'node:readline';

The following simple example illustrates the basic use of the node:readline module.

import * as readline from 'node:readline/promises';
import { stdin as input, stdout as output } from 'node:process';

const rl = readline.createInterface({ input, output });

const answer = await rl.question('What do you think of Node.js? ');

console.log(`Thank you for your valuable feedback: ${answer}`);

rl.close();

Once this code is invoked, the Node.js application will not terminate until the readline.Interface is closed because the interface waits for data to be received on the input stream.

Usage in Deno

import * as mod from "node:readline";

class Interface

extends EventEmitter

Usage in Deno

import { Interface } from "node:readline";

Instances of the readline.Interface class are constructed using the readline.createInterface() method. Every instance is associated with a single input Readable stream and a single output Writable stream. The output stream is used to print prompts for user input that arrives on, and is read from, the input stream.

Constructors

Interface(

input: ReadableStream,

output?: WritableStream,

completer?: Completer | AsyncCompleter,

terminal?: boolean,
)

new

NOTE: According to the documentation:

Instances of the readline.Interface class are constructed using the readline.createInterface() method.

Interface(options: ReadLineOptions)

new

NOTE: According to the documentation:

Instances of the readline.Interface class are constructed using the readline.createInterface() method.

Properties

cursor: number

readonly

The cursor position relative to rl.line.

This will track where the current cursor lands in the input string, when reading input from a TTY stream. The position of cursor determines the portion of the input string that will be modified as input is processed, as well as the column where the terminal caret will be rendered.

line: string

readonly

The current input data being processed by node.

This can be used when collecting input from a TTY stream to retrieve the current value that has been processed thus far, prior to the line event being emitted. Once the line event has been emitted, this property will be an empty string.

Be aware that modifying the value during the instance runtime may have unintended consequences if rl.cursor is not also controlled.

If not using a TTY stream for input, use the 'line' event.

One possible use case would be as follows:

const values = ['lorem ipsum', 'dolor sit amet'];
const rl = readline.createInterface(process.stdin);
const showResults = debounce(() => {
  console.log(
    '\n',
    values.filter((val) => val.startsWith(rl.line)).join(' '),
  );
}, 300);
process.stdin.on('keypress', (c, k) => {
  showResults();
});

terminal: boolean

readonly

Methods

[Symbol.asyncIterator](): AsyncIterator<string>

addListener(

event: string,

listener: (...args: any[]) => void,
): this

events.EventEmitter

close
line
pause
resume
SIGCONT
SIGINT
SIGTSTP
history

addListener(

event: "close",

listener: () => void,
): this

addListener(

event: "line",

listener: (input: string) => void,
): this

addListener(

event: "pause",

listener: () => void,
): this

addListener(

event: "resume",

listener: () => void,
): this

addListener(

event: "SIGCONT",

listener: () => void,
): this

addListener(

event: "SIGINT",

listener: () => void,
): this

addListener(

event: "SIGTSTP",

listener: () => void,
): this

addListener(

event: "history",

listener: (history: string[]) => void,
): this

close(): void

The rl.close() method closes the Interface instance and relinquishes control over the input and output streams. When called, the 'close' event will be emitted.

Calling rl.close() does not immediately stop other events (including 'line') from being emitted by the Interface instance.

emit(

event: string | symbol,

...args: any[],
): boolean

emit(event: "close"): boolean

emit(

event: "line",

input: string,
): boolean

emit(event: "pause"): boolean

emit(event: "resume"): boolean

emit(event: "SIGCONT"): boolean

emit(event: "SIGINT"): boolean

emit(event: "SIGTSTP"): boolean

emit(

event: "history",

history: string[],
): boolean

getCursorPos(): CursorPos

Returns the real position of the cursor in relation to the input prompt + string. Long input (wrapping) strings, as well as multiple line prompts are included in the calculations.

getPrompt(): string

The rl.getPrompt() method returns the current prompt used by rl.prompt().

on(

event: string,

listener: (...args: any[]) => void,
): this

on(

event: "close",

listener: () => void,
): this

on(

event: "line",

listener: (input: string) => void,
): this

on(

event: "pause",

listener: () => void,
): this

on(

event: "resume",

listener: () => void,
): this

on(

event: "SIGCONT",

listener: () => void,
): this

on(

event: "SIGINT",

listener: () => void,
): this

on(

event: "SIGTSTP",

listener: () => void,
): this

on(

event: "history",

listener: (history: string[]) => void,
): this

once(

event: string,

listener: (...args: any[]) => void,
): this

once(

event: "close",

listener: () => void,
): this

once(

event: "line",

listener: (input: string) => void,
): this

once(

event: "pause",

listener: () => void,
): this

once(

event: "resume",

listener: () => void,
): this

once(

event: "SIGCONT",

listener: () => void,
): this

once(

event: "SIGINT",

listener: () => void,
): this

once(

event: "SIGTSTP",

listener: () => void,
): this

once(

event: "history",

listener: (history: string[]) => void,
): this

pause(): this

The rl.pause() method pauses the input stream, allowing it to be resumed later if necessary.

Calling rl.pause() does not immediately pause other events (including 'line') from being emitted by the Interface instance.

prependListener(

event: string,

listener: (...args: any[]) => void,
): this

prependListener(

event: "close",

listener: () => void,
): this

prependListener(

event: "line",

listener: (input: string) => void,
): this

prependListener(

event: "pause",

listener: () => void,
): this

prependListener(

event: "resume",

listener: () => void,
): this

prependListener(

event: "SIGCONT",

listener: () => void,
): this

prependListener(

event: "SIGINT",

listener: () => void,
): this

prependListener(

event: "SIGTSTP",

listener: () => void,
): this

prependListener(

event: "history",

listener: (history: string[]) => void,
): this

prependOnceListener(

event: string,

listener: (...args: any[]) => void,
): this

prependOnceListener(

event: "close",

listener: () => void,
): this

prependOnceListener(

event: "line",

listener: (input: string) => void,
): this

prependOnceListener(

event: "pause",

listener: () => void,
): this

prependOnceListener(

event: "resume",

listener: () => void,
): this

prependOnceListener(

event: "SIGCONT",

listener: () => void,
): this

prependOnceListener(

event: "SIGINT",

listener: () => void,
): this

prependOnceListener(

event: "SIGTSTP",

listener: () => void,
): this

prependOnceListener(

event: "history",

listener: (history: string[]) => void,
): this

prompt(preserveCursor?: boolean): void

The rl.prompt() method writes the Interface instances configuredprompt to a new line in output in order to provide a user with a new location at which to provide input.

When called, rl.prompt() will resume the input stream if it has been paused.

If the Interface was created with output set to null or undefined the prompt is not written.

question(

query: string,

callback: (answer: string) => void,
): void

The rl.question() method displays the query by writing it to the output, waits for user input to be provided on input, then invokes the callback function passing the provided input as the first argument.

When called, rl.question() will resume the input stream if it has been paused.

If the Interface was created with output set to null or undefined the query is not written.

The callback function passed to rl.question() does not follow the typical pattern of accepting an Error object or null as the first argument. The callback is called with the provided answer as the only argument.

An error will be thrown if calling rl.question() after rl.close().

Example usage:

rl.question('What is your favorite food? ', (answer) => {
  console.log(`Oh, so your favorite food is ${answer}`);
});

Using an AbortController to cancel a question.

const ac = new AbortController();
const signal = ac.signal;

rl.question('What is your favorite food? ', { signal }, (answer) => {
  console.log(`Oh, so your favorite food is ${answer}`);
});

signal.addEventListener('abort', () => {
  console.log('The food question timed out');
}, { once: true });

setTimeout(() => ac.abort(), 10000);

question(

query: string,

options: Abortable,

callback: (answer: string) => void,
): void

resume(): this

The rl.resume() method resumes the input stream if it has been paused.

setPrompt(prompt: string): void

The rl.setPrompt() method sets the prompt that will be written to output whenever rl.prompt() is called.

write(

data: string | Buffer,

key?: Key,
): void

The rl.write() method will write either data or a key sequence identified by key to the output. The key argument is supported only if output is a TTY text terminal. See TTY keybindings for a list of key combinations.

If key is specified, data is ignored.

When called, rl.write() will resume the input stream if it has been paused.

If the Interface was created with output set to null or undefined the data and key are not written.

rl.write('Delete this!');
// Simulate Ctrl+U to delete the line written previously
rl.write(null, { ctrl: true, name: 'u' });

The rl.write() method will write the data to the readline Interface's input as if it were provided by the user.

write(

data: 
undefined
 | null
 | string
 | Buffer
,

key: Key,
): void

class promises.Interface

extends _Interface

Usage in Deno

import { promises } from "node:readline";
const { Interface } = promises;

Instances of the readlinePromises.Interface class are constructed using the readlinePromises.createInterface() method. Every instance is associated with a single input Readable stream and a single output Writable stream. The output stream is used to print prompts for user input that arrives on, and is read from, the input stream.

Methods

question(query: string): Promise<string>

When called, rl.question() will resume the input stream if it has been paused.

If the Interface was created with output set to null or undefined the query is not written.

If the question is called after rl.close(), it returns a rejected promise.

Example usage:

const answer = await rl.question('What is your favorite food? ');
console.log(`Oh, so your favorite food is ${answer}`);

Using an AbortSignal to cancel a question.

const signal = AbortSignal.timeout(10_000);

signal.addEventListener('abort', () => {
  console.log('The food question timed out');
}, { once: true });

const answer = await rl.question('What is your favorite food? ', { signal });
console.log(`Oh, so your favorite food is ${answer}`);

question(

query: string,

options: Abortable,
): Promise<string>

class promises.Readline

Usage in Deno

import { promises } from "node:readline";
const { Readline } = promises;

Constructors

Readline(

stream: WritableStream,

options?: { autoCommit?: boolean;  },
)

new

Methods

clearLine(dir: Direction): this

The rl.clearLine() method adds to the internal list of pending action an action that clears current line of the associated stream in a specified direction identified by dir. Call rl.commit() to see the effect of this method, unless autoCommit: true was passed to the constructor.

clearScreenDown(): this

The rl.clearScreenDown() method adds to the internal list of pending action an action that clears the associated stream from the current position of the cursor down. Call rl.commit() to see the effect of this method, unless autoCommit: true was passed to the constructor.

commit(): Promise<void>

The rl.commit() method sends all the pending actions to the associated stream and clears the internal list of pending actions.

cursorTo(

x: number,

y?: number,
): this

The rl.cursorTo() method adds to the internal list of pending action an action that moves cursor to the specified position in the associated stream. Call rl.commit() to see the effect of this method, unless autoCommit: true was passed to the constructor.

moveCursor(

dx: number,

dy: number,
): this

The rl.moveCursor() method adds to the internal list of pending action an action that moves the cursor relative to its current position in the associated stream. Call rl.commit() to see the effect of this method, unless autoCommit: true was passed to the constructor.

rollback(): this

The rl.rollback methods clears the internal list of pending actions without sending it to the associated stream.

function clearLine

Usage in Deno

import { clearLine } from "node:readline";

clearLine(

stream: WritableStream,

dir: Direction,

callback?: () => void,
): boolean

The readline.clearLine() method clears current line of given TTY stream in a specified direction identified by dir.

Parameters

stream: WritableStream

dir: Direction

callback: () => void

optional

Invoked once the operation completes.

Return Type

boolean

false if stream wishes for the calling code to wait for the 'drain' event to be emitted before continuing to write additional data; otherwise true.

function clearScreenDown

Usage in Deno

import { clearScreenDown } from "node:readline";

clearScreenDown(

stream: WritableStream,

callback?: () => void,
): boolean

The readline.clearScreenDown() method clears the given TTY stream from the current position of the cursor down.

Parameters

stream: WritableStream

callback: () => void

optional

Invoked once the operation completes.

Return Type

boolean

false if stream wishes for the calling code to wait for the 'drain' event to be emitted before continuing to write additional data; otherwise true.

function createInterface

Usage in Deno

import { createInterface } from "node:readline";

Overload 1

createInterface(

input: ReadableStream,

output?: WritableStream,

completer?: Completer | AsyncCompleter,

terminal?: boolean,
): Interface

The readline.createInterface() method creates a new readline.Interface instance.

import readline from 'node:readline';
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

Once the readline.Interface instance is created, the most common case is to listen for the 'line' event:

rl.on('line', (line) => {
  console.log(`Received: ${line}`);
});

If terminal is true for this instance then the output stream will get the best compatibility if it defines an output.columns property and emits a 'resize' event on the output if or when the columns ever change (process.stdout does this automatically when it is a TTY).

When creating a readline.Interface using stdin as input, the program will not terminate until it receives an EOF character. To exit without waiting for user input, call process.stdin.unref().

Parameters

input: ReadableStream

output: WritableStream

optional

completer: Completer | AsyncCompleter

optional

terminal: boolean

optional

Return Type

Interface

Overload 2

createInterface(options: ReadLineOptions): Interface

Parameters

options: ReadLineOptions

Return Type

Interface

function cursorTo

Usage in Deno

import { cursorTo } from "node:readline";

cursorTo(

stream: WritableStream,

x: number,

y?: number,

callback?: () => void,
): boolean

The readline.cursorTo() method moves cursor to the specified position in a given TTY stream.

Parameters

stream: WritableStream

x: number

y: number

optional

callback: () => void

optional

Invoked once the operation completes.

Return Type

boolean

false if stream wishes for the calling code to wait for the 'drain' event to be emitted before continuing to write additional data; otherwise true.

function emitKeypressEvents

Usage in Deno

import { emitKeypressEvents } from "node:readline";

emitKeypressEvents(

stream: ReadableStream,

readlineInterface?: Interface,
): void

The readline.emitKeypressEvents() method causes the given Readable stream to begin emitting 'keypress' events corresponding to received input.

Optionally, interface specifies a readline.Interface instance for which autocompletion is disabled when copy-pasted input is detected.

If the stream is a TTY, then it must be in raw mode.

This is automatically called by any readline instance on its input if the input is a terminal. Closing the readline instance does not stop the input from emitting 'keypress' events.

readline.emitKeypressEvents(process.stdin);
if (process.stdin.isTTY)
  process.stdin.setRawMode(true);

Example: Tiny CLI

The following example illustrates the use of readline.Interface class to implement a small command-line interface:

import readline from 'node:readline';
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  prompt: 'OHAI> ',
});

rl.prompt();

rl.on('line', (line) => {
  switch (line.trim()) {
    case 'hello':
      console.log('world!');
      break;
    default:
      console.log(`Say what? I might have heard '${line.trim()}'`);
      break;
  }
  rl.prompt();
}).on('close', () => {
  console.log('Have a great day!');
  process.exit(0);
});

Example: Read file stream line-by-Line

A common use case for readline is to consume an input file one line at a time. The easiest way to do so is leveraging the fs.ReadStream API as well as a for await...of loop:

import fs from 'node:fs';
import readline from 'node:readline';

async function processLineByLine() {
  const fileStream = fs.createReadStream('input.txt');

  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity,
  });
  // Note: we use the crlfDelay option to recognize all instances of CR LF
  // ('\r\n') in input.txt as a single line break.

  for await (const line of rl) {
    // Each line in input.txt will be successively available here as `line`.
    console.log(`Line from file: ${line}`);
  }
}

processLineByLine();

Alternatively, one could use the 'line' event:

import fs from 'node:fs';
import readline from 'node:readline';

const rl = readline.createInterface({
  input: fs.createReadStream('sample.txt'),
  crlfDelay: Infinity,
});

rl.on('line', (line) => {
  console.log(`Line from file: ${line}`);
});

Currently, for await...of loop can be a bit slower. If async / await flow and speed are both essential, a mixed approach can be applied:

import { once } from 'node:events';
import { createReadStream } from 'node:fs';
import { createInterface } from 'node:readline';

(async function processLineByLine() {
  try {
    const rl = createInterface({
      input: createReadStream('big-file.txt'),
      crlfDelay: Infinity,
    });

    rl.on('line', (line) => {
      // Process the line.
    });

    await once(rl, 'close');

    console.log('File processed.');
  } catch (err) {
    console.error(err);
  }
})();

Parameters

stream: ReadableStream

readlineInterface: Interface

optional

Return Type

void

function moveCursor

Usage in Deno

import { moveCursor } from "node:readline";

moveCursor(

stream: WritableStream,

dx: number,

dy: number,

callback?: () => void,
): boolean

The readline.moveCursor() method moves the cursor relative to its current position in a given TTY stream.

Parameters

stream: WritableStream

dx: number

dy: number

callback: () => void

optional

Invoked once the operation completes.

Return Type

boolean

false if stream wishes for the calling code to wait for the 'drain' event to be emitted before continuing to write additional data; otherwise true.

function promises.createInterface

Usage in Deno

import { promises } from "node:readline";
const { createInterface } = promises;

Overload 1

createInterface(

input: ReadableStream,

output?: WritableStream,

completer?: Completer,

terminal?: boolean,
): Interface

The readlinePromises.createInterface() method creates a new readlinePromises.Interface instance.

import readlinePromises from 'node:readline/promises';
const rl = readlinePromises.createInterface({
  input: process.stdin,
  output: process.stdout,
});

Once the readlinePromises.Interface instance is created, the most common case is to listen for the 'line' event:

rl.on('line', (line) => {
  console.log(`Received: ${line}`);
});

Parameters

input: ReadableStream

output: WritableStream

optional

completer: Completer

optional

terminal: boolean

optional

Return Type

Interface

Overload 2

createInterface(options: ReadLineOptions): Interface

Parameters

options: ReadLineOptions

Return Type

Interface

interface CursorPos

Usage in Deno

import { type CursorPos } from "node:readline";

Properties

rows: number

cols: number

interface Key

Usage in Deno

import { type Key } from "node:readline";

Properties

sequence: string | undefined

optional

name: string | undefined

optional

ctrl: boolean | undefined

optional

meta: boolean | undefined

optional

shift: boolean | undefined

optional

interface promises.ReadLineOptions

extends Omit<_ReadLineOptions, "completer">

Usage in Deno

import { type promises } from "node:readline";
type { ReadLineOptions } = promises;

Properties

completer: Completer | undefined

optional

An optional function used for Tab autocompletion.

interface ReadLineOptions

Usage in Deno

import { type ReadLineOptions } from "node:readline";

Properties

input: ReadableStream

The Readable stream to listen to

output: WritableStream | undefined

optional

The Writable stream to write readline data to.

completer: 
Completer
 | AsyncCompleter
 | undefined

optional

An optional function used for Tab autocompletion.

terminal: boolean | undefined

optional

true if the input and output streams should be treated like a TTY, and have ANSI/VT100 escape codes written to it. Default: checking isTTY on the output stream upon instantiation.

history: string[] | undefined

optional

Initial list of history lines. This option makes sense only if terminal is set to true by the user or by an internal output check, otherwise the history caching mechanism is not initialized at all.

historySize: number | undefined

optional

Maximum number of history lines retained. To disable the history set this value to 0. This option makes sense only if terminal is set to true by the user or by an internal output check, otherwise the history caching mechanism is not initialized at all.

removeHistoryDuplicates: boolean | undefined

optional

If true, when a new input line added to the history list duplicates an older one, this removes the older line from the list.

prompt: string | undefined

optional

The prompt string to use.

crlfDelay: number | undefined

optional

If the delay between \r and \n exceeds crlfDelay milliseconds, both \r and \n will be treated as separate end-of-line input. crlfDelay will be coerced to a number no less than 100. It can be set to Infinity, in which case \r followed by \n will always be considered a single newline (which may be reasonable for reading files with \r\n line delimiter).

escapeCodeTimeout: number | undefined

optional

The duration readline will wait for a character (when reading an ambiguous key sequence in milliseconds one that can both form a complete key sequence using the input read so far and can take additional input to complete a longer key sequence).

tabSize: number | undefined

optional

The number of spaces a tab is equal to (minimum 1).

signal: AbortSignal | undefined

optional

Allows closing the interface using an AbortSignal. Aborting the signal will internally call close on the interface.

namespace promises

unstable

Usage in Deno

import { promises } from "node:readline";

Classes

promises.Interface

question

promises.Readline

No documentation available

Functions

promises.createInterface

The readlinePromises.createInterface() method creates a new readlinePromises.Interface instance.

Interfaces

promises.ReadLineOptions

No documentation available

completer

Type Aliases

promises.Completer

No documentation available

type alias AsyncCompleter

Usage in Deno

import { type AsyncCompleter } from "node:readline";

Definition

(

line: string,

callback: (

err?: null | Error,

result?: CompleterResult,
) => void,
) => void

type alias Completer

Usage in Deno

import { type Completer } from "node:readline";

Definition

(line: string) => CompleterResult

type alias CompleterResult

Usage in Deno

import { type CompleterResult } from "node:readline";

Definition

[string[], string]

type alias Direction

Usage in Deno

import { type Direction } from "node:readline";

Definition


-1
 | 0
 | 1

type alias promises.Completer

Usage in Deno

import { type promises } from "node:readline";
type { Completer } = promises;

Definition

(line: string) => CompleterResult | Promise<CompleterResult>

type alias ReadLine

Usage in Deno

import { type ReadLine } from "node:readline";

Definition

Interface