Node.js readline: Read User Input From the Terminal

To read user input in Node.js, create a readline interface on process.stdin and ask with rl.question(). Node.js has no prompt(): the browser's version opens a dialog, and a terminal program has none. The modern form uses readline/promises, where await rl.question('Name? ') returns the line the user typed. Close the interface when you are done, or the program keeps waiting for more input.

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

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

const age = await rl.question('How old are you? ');
rl.close();

console.log(`Next year you will be ${Number(age) + 1}.`);

question() printed its prompt, waited for one line of input, and returned it without the newline, so the program printed Next year you will be 37. For several questions, await one question() after another.

readline question() with a callback

The original API, in every Node.js version, passes the answer to a callback. Nested questions nest callbacks:

// input: blue
const readline = require('readline');

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

rl.question('Favorite color? ', (answer) => {
    console.log(`You picked ${answer.trim().toLowerCase()}.`);
    rl.close();
});

It printed the prompt, then You picked blue. The answer is a plain string, so trim it before comparing: a user who types a space after the word otherwise gets 'blue ', which is not equal to 'blue'.

Read input line by line

To process every line until the input ends, iterate the interface with for await. This is how a program reads a list typed by the user (ended with Ctrl+D) or a file piped into it with node index.js < numbers.txt. Older code does the same with events, rl.on('line', fn) for each line and rl.on('close', fn) at the end; the loop is that pair of events written top to bottom:

// input: 12
// input: 7
// input: 30
const readline = require('readline');

async function main() {
    const rl = readline.createInterface({ input: process.stdin });
    let total = 0;
    let count = 0;

    for await (const line of rl) {
        total += Number(line);
        count += 1;
    }

    console.log(`${count} numbers, total ${total}`);
}

main();

It printed 3 numbers, total 49, and the loop ended by itself when the input ended, so no close() is needed. Add a fourth input line, 1, and the result becomes 4 numbers, total 50.

Read all of stdin at once

For input piped from another program (cat data.txt | node index.js), reading everything in one call is simpler. File descriptor 0 is standard input. A file saved on Windows may end its lines with \r\n, so split on /\r?\n/ when the input can come from there:

// input: apples 3
// input: bread 1
// input: cheese 2
const fs = require('fs');

const text = fs.readFileSync(0, 'utf8');
const lines = text.trim().split(/\r?\n/);

for (const line of lines) {
    const [item, qty] = line.split(' ');
    console.log(item.padEnd(8), 'x', qty);
}

It printed the three items in a column. readFileSync(0) blocks until the input is complete, which is fine for a script that reads a pipe and fine for tests, but wrong for an interactive tool, where the user would type everything before seeing any prompt.

Which one to use

All four read the same standard input. They differ in when your code gets the text: one answer at a time, one line at a time, or everything at the end.

Common mistakes

Forgetting rl.close(). The interface keeps standard input open, so the program never exits after the last question. Close it once you have every answer.

Using the answer as a number. Like everything typed in a terminal, the answer is a string. '36' + 1 is '361'; convert with Number() first.

Piping several answers into several questions. When input comes from a pipe instead of a keyboard, readline reads all of it at once, and a line that arrives before its question() is asked is dropped. For piped input, use the for await loop or readFileSync(0).

Leaving out the output option. Without output: process.stdout, question() never prints its prompt, and the user stares at a blank terminal. The line-by-line loop does not need it, because it prints nothing.