Класс: InterfaceConstructor

• Наследует: <EventEmitter>

Экземпляры класса InterfaceConstructor создаются с помощью метода readlinePromises.createInterface() или readline.createInterface(). Каждый экземпляр связан с одним потоком input Readable и одним потоком output Writable. Поток output используется для вывода подсказок для пользовательского ввода, поступающего из потока input и считываемого из него.

Событие: 'close'

Событие 'close' генерируется в одном из следующих случаев:

• Вызывается метод rl.close(), и экземпляр InterfaceConstructor освобождает управление потоками input и output;
• Поток input получает событие 'end';
• Поток input получает Ctrl+D, сигнализируя о конце передачи данных (EOT);
• Поток input получает Ctrl+C, сигнализируя о SIGINT, и для экземпляра 'SIGINT' не зарегистрирован обработчик события InterfaceConstructor.

Функция-обработчик вызывается без аргументов.

Работа экземпляра InterfaceConstructor завершается после генерации события 'close'.

Событие: 'line'

Событие 'line' генерируется всякий раз, когда поток input получает символ конца строки (\n, \r или \r\n). Обычно это происходит, когда пользователь нажимает Enter или Return.

Событие 'line' также генерируется, если из потока были прочитаны новые данные, а поток завершается без завершающего символа конца строки.

Функция-обработчик вызывается со строкой, содержащей одну строку полученных данных.

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

Событие: 'history'

Событие 'history' генерируется всякий раз, когда массив истории изменяется.

Функция-обработчик вызывается с массивом, содержащим массив истории. Он отражает все изменения, добавленные и удалённые строки, появившиеся в результате historySize и removeHistoryDuplicates.

Основная цель — дать обработчику возможность сохранять историю. Обработчик также может изменять объект истории. Это может быть полезно, чтобы запретить добавление в историю определённых строк, например пароля.

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

Событие: 'pause'

Событие 'pause' генерируется в одном из следующих случаев:

• Поток input приостановлен.
• Поток input не приостановлен и получает событие 'SIGCONT'. (См. события 'SIGTSTP' и 'SIGCONT'.)

Функция-обработчик вызывается без аргументов.

rl.on('pause', () => {
  console.log('Readline paused.');
}); copy

Событие: 'resume'

Событие 'resume' генерируется всякий раз, когда поток input возобновляет работу.

Функция-обработчик вызывается без аргументов.

rl.on('resume', () => {
  console.log('Readline resumed.');
}); copy

Событие: 'SIGCONT'

Событие 'SIGCONT' генерируется, когда процесс Node.js, ранее переведённый в фоновый режим с помощью Ctrl+Z (то есть SIGTSTP), возвращается на передний план с помощью fg(1p).

Если поток input был приостановлен до запроса SIGTSTP, это событие не будет сгенерировано.

Функция-обработчик вызывается без аргументов.

rl.on('SIGCONT', () => {
  // `prompt` will automatically resume the stream
  rl.prompt();
}); copy

Событие 'SIGCONT' не поддерживается в Windows.

Событие: 'SIGINT'

Событие 'SIGINT' генерируется всякий раз, когда поток input получает ввод Ctrl+C, обычно называемый SIGINT. Если при получении потоком input символа SIGINT не зарегистрированы обработчики события 'SIGINT', будет сгенерировано событие 'pause'.

Функция-обработчик вызывается без аргументов.

rl.on('SIGINT', () => {
  rl.question('Are you sure you want to exit? ', (answer) => {
    if (answer.match(/^y(es)?$/i)) rl.pause();
  });
}); copy

Событие: 'SIGTSTP'

Событие 'SIGTSTP' генерируется, когда поток input получает ввод Ctrl+Z, обычно называемый SIGTSTP. Если при получении потоком input символа SIGTSTP не зарегистрированы обработчики события 'SIGTSTP', процесс Node.js будет переведён в фоновый режим.

После возобновления работы программы с помощью fg(1p) будут сгенерированы события 'pause' и 'SIGCONT'. Их можно использовать для возобновления потока input.

События 'pause' и 'SIGCONT' не будут сгенерированы, если input был приостановлен до перевода процесса в фоновый режим.

Функция-обработчик вызывается без аргументов.

rl.on('SIGTSTP', () => {
  // This will override SIGTSTP and prevent the program from going to the
  // background.
  console.log('Caught SIGTSTP.');
}); copy

Событие 'SIGTSTP' не поддерживается в Windows.

rl.close()

Метод rl.close() закрывает экземпляр InterfaceConstructor и освобождает управление потоками input и output. При его вызове будет сгенерировано событие 'close'.

Вызов rl.close() не останавливает немедленно генерацию других событий (включая 'line') экземпляром InterfaceConstructor.

rl.pause()

Метод rl.pause() приостанавливает поток input, позволяя при необходимости возобновить его позднее.

Вызов rl.pause() не останавливает немедленно генерацию других событий (включая 'line') экземпляром InterfaceConstructor.

rl.prompt([preserveCursor])

• preserveCursor <boolean> Если значение true, сброс позиции курсора в 0 предотвращается.

Метод rl.prompt() записывает настроенное значение prompt экземпляра InterfaceConstructor в новую строку в output, чтобы предоставить пользователю новое место для ввода данных.

При вызове rl.prompt() возобновляет поток input, если он был приостановлен.

Если InterfaceConstructor был создан со значением null или undefined для параметра output, подсказка не выводится.

rl.resume()

Метод rl.resume() возобновляет поток input, если он был приостановлен.

rl.setPrompt(prompt)

• prompt <string>

Метод rl.setPrompt() задаёт подсказку, которая будет выводиться в output при каждом вызове rl.prompt().

rl.getPrompt()

• Возвращает: <string> текущую строку подсказки

Метод rl.getPrompt() возвращает текущую подсказку, используемую rl.prompt().

rl.write(data[, key])

• data <string>
• key <Object>
  • ctrl <boolean> true для обозначения клавиши Ctrl.
  • meta <boolean> true для обозначения клавиши Meta.
  • shift <boolean> true для обозначения клавиши Shift.
  • name <string> Название клавиши.

Метод rl.write() записывает в output либо data, либо последовательность клавиш, определяемую key. Аргумент key поддерживается только в том случае, если output является текстовым терминалом TTY. Список сочетаний клавиш см. в разделе Сочетания клавиш TTY.

Если указан key, data игнорируется.

При вызове rl.write() возобновляет поток input, если он был приостановлен.

Если InterfaceConstructor был создан со значением null или undefined для параметра output, data и key не записываются.

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

Метод rl.write() записывает данные в readline Interface, в его input, как если бы они были введены пользователем.

rl[Symbol.asyncIterator]()

• Возвращает: <AsyncIterator>

Создаёт объект AsyncIterator, который перебирает каждую строку входного потока как строку. Этот метод позволяет асинхронно перебирать объекты InterfaceConstructor с помощью циклов for await...of.

Ошибки входного потока не передаются дальше.

Если цикл завершается с помощью break, throw или return, будет вызван rl.close(). Иными словами, перебор InterfaceConstructor всегда приводит к полному считыванию входного потока.

Производительность уступает традиционному API событий 'line'. Для приложений, чувствительных к производительности, используйте 'line'.

async function processLineByLine() {
  const rl = readline.createInterface({
    // ...
  });

  for await (const line of rl) {
    // Each line in the readline input will be successively available here as
    // `line`.
  }
} copy

readline.createInterface() начинает считывать входной поток сразу после вызова. Асинхронные операции между созданием интерфейса и асинхронным перебором могут привести к пропуску строк.

rl.line

• <string>

Текущие входные данные, обрабатываемые node.

При сборе ввода из потока TTY это свойство можно использовать для получения текущего значения, обработанного к этому моменту, до генерации события line. После генерации события line это свойство будет содержать пустую строку.

Обратите внимание, что изменение значения во время работы экземпляра может привести к непредвиденным последствиям, если также не контролируется rl.cursor.

Если для ввода не используется поток TTY, используйте событие 'line'.

Один из возможных вариантов использования:

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

rl.cursor

• <number> | <undefined>

Позиция курсора относительно rl.line.

При чтении ввода из потока TTY это свойство отслеживает положение текущего курсора в строке ввода. Позиция курсора определяет, какая часть строки ввода будет изменена при обработке ввода, а также столбец, в котором будет отображаться курсор терминала.

rl.getCursorPos()

• Возвращает: <Object>
  • rows <number> строка подсказки, на которой в данный момент находится курсор
  • cols <number> столбец экрана, в котором в данный момент находится курсор

Возвращает фактическую позицию курсора относительно строки подсказки и ввода. При вычислении учитываются длинные строки ввода с переносами, а также многострочные подсказки.

API промисов

Класс: readlinePromises.Interface

• Наследует: <readline.InterfaceConstructor>

Экземпляры класса readlinePromises.Interface создаются с помощью метода readlinePromises.createInterface(). Каждый экземпляр связан с одним потоком input Readable и одним потоком output Writable. Поток output используется для вывода приглашений для ввода пользователя, поступающего в поток input и считываемого из него.

rl.question(query[, options])

• query <string> Инструкция или запрос для записи в output перед приглашением.
• options <Object>
  • signal <AbortSignal> Позволяет отменить question() с помощью AbortSignal.
• Возвращает: <Promise> Промис, который разрешается вводом пользователя в ответ на query.

Метод rl.question() отображает query, записывая его в output, ожидает ввода пользователя в input, а затем вызывает функцию callback, передавая введённые данные в качестве первого аргумента.

При вызове rl.question() возобновит поток input, если он был приостановлен.

Если объект readlinePromises.Interface создан с параметром output, установленным в null или undefined, query не записывается.

Если метод question вызывается после rl.close(), он возвращает отклонённый промис.

Пример использования:

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

Использование AbortSignal для отмены вопроса.

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}`); copy

Класс: readlinePromises.Readline

new readlinePromises.Readline(stream[, options])

• stream <stream.Writable> Поток TTY.
• options <Object>
  • autoCommit <boolean> Если true, вызывать rl.commit() не нужно.

rl.clearLine(dir)

• dir <integer>
  • -1: слева от курсора
  • 1: справа от курсора
  • 0: вся строка
• Возвращает: this

Метод rl.clearLine() добавляет во внутренний список ожидающих действий действие, которое очищает текущую строку связанного stream в направлении, указанном параметром dir. Вызовите rl.commit(), чтобы увидеть результат работы этого метода, если только при создании объекта не был передан параметр autoCommit: true.

rl.clearScreenDown()

• Возвращает: this

Метод rl.clearScreenDown() добавляет во внутренний список ожидающих действий действие, которое очищает связанный поток от текущего положения курсора до конца. Вызовите rl.commit(), чтобы увидеть результат работы этого метода, если только при создании объекта не был передан параметр autoCommit: true.

rl.commit()

• Возвращает: <Promise>

Метод rl.commit() отправляет все ожидающие действия в связанный stream и очищает внутренний список ожидающих действий.

rl.cursorTo(x[, y])

• x <integer>
• y <integer>
• Возвращает: this

Метод rl.cursorTo() добавляет во внутренний список ожидающих действий действие, которое перемещает курсор в указанное положение в связанном stream. Вызовите rl.commit(), чтобы увидеть результат работы этого метода, если только при создании объекта не был передан параметр autoCommit: true.

rl.moveCursor(dx, dy)

• dx <integer>
• dy <integer>
• Возвращает: this

Метод rl.moveCursor() добавляет во внутренний список ожидающих действий действие, которое перемещает курсор относительно его текущего положения в связанном stream. Вызовите rl.commit(), чтобы увидеть результат работы этого метода, если только при создании объекта не был передан параметр autoCommit: true.

rl.rollback()

• Возвращает: this

Метод rl.rollback очищает внутренний список ожидающих действий, не отправляя их в связанный stream.

readlinePromises.createInterface(options)

• options <Object>
  • input <stream.Readable> Поток Readable, за которым нужно следить. Этот параметр обязателен.
  • output <stream.Writable> Поток Writable, в который записываются данные readline.
  • completer <Function> Необязательная функция для автодополнения по клавише Tab.
  • terminal <boolean> true, если потоки input и output следует считать потоками TTY и записывать в них управляющие последовательности ANSI/VT100. По умолчанию: проверка isTTY в потоке output при создании экземпляра.
  • history <string[]> Начальный список строк истории. Этот параметр имеет смысл только в том случае, если terminal установлен в true пользователем или внутренней проверкой output; в противном случае механизм кэширования истории вообще не инициализируется. По умолчанию: [].
  • historySize <number> Максимальное количество сохраняемых строк истории. Чтобы отключить историю, установите это значение в 0. Этот параметр имеет смысл только в том случае, если terminal установлен в true пользователем или внутренней проверкой output; в противном случае механизм кэширования истории вообще не инициализируется. По умолчанию: 30.
  • removeHistoryDuplicates <boolean> Если true, при добавлении в список истории новой строки ввода, дублирующей более старую, старая строка удаляется из списка. По умолчанию: false.
  • prompt <string> Строка приглашения. По умолчанию: '> '.
  • crlfDelay <number> Если задержка между \r и \n превышает crlfDelay миллисекунд, \r и \n будут обрабатываться как отдельные символы конца строки ввода. crlfDelay будет приведено к числу не меньше 100. Можно установить значение Infinity — в этом случае \r, за которым следует \n, всегда будет считаться одним символом новой строки (что может быть удобно при чтении файлов с разделителем строк \r\n). По умолчанию: 100.
  • escapeCodeTimeout <number> Время, в течение которого readlinePromises будет ожидать символ (при чтении неоднозначной последовательности клавиш, которая с учётом уже прочитанных данных может как образовывать полную последовательность клавиш, так и принимать дополнительные данные для завершения более длинной последовательности). По умолчанию: 500.
  • tabSize <integer> Количество пробелов, соответствующее символу табуляции (минимум 1). По умолчанию: 8.
  • signal <AbortSignal> Позволяет закрыть интерфейс с помощью AbortSignal.
• Возвращает: <readlinePromises.Interface>

Метод readlinePromises.createInterface() создаёт новый экземпляр readlinePromises.Interface.

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

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

После создания экземпляра readlinePromises.Interface чаще всего прослушивают событие 'line':

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

Если для этого экземпляра terminal — true, поток output будет наиболее совместимым, если в нём определено свойство output.columns и генерируется событие 'resize' при изменении количества столбцов или в момент такого изменения на output (process.stdout делает это автоматически, если является TTY).

Использование функции completer

Функция completer принимает в качестве аргумента текущую строку, введённую пользователем, и возвращает Array с двумя элементами:

• Array с подходящими вариантами автодополнения.
• Подстрока, использованная для поиска совпадений.

Например: [[substr1, substr2, ...], originalsubstring].

function completer(line) {
  const completions = '.help .error .exit .quit .q'.split(' ');
  const hits = completions.filter((c) => c.startsWith(line));
  // Show all completions if none found
  return [hits.length ? hits : completions, line];
} copy

Функция completer также может возвращать <Promise> или быть асинхронной:

async function completer(linePartial) {
  await someAsyncWork();
  return [['123'], linePartial];
} copy

API обратного вызова

Класс: readline.Interface

• Расширяет: <readline.InterfaceConstructor>

Экземпляры класса readline.Interface создаются с помощью метода readline.createInterface(). Каждый экземпляр связан с одним потоком Readable input и одним потоком Writable output. Поток output используется для вывода приглашений к вводу, который поступает в поток input и считывается из него.

rl.question(query[, options], callback)

• query <string> Инструкция или запрос, который нужно записать в output перед приглашением.
• options <Object>
  • signal <AbortSignal> Позволяет отменить question() с помощью AbortController.
• callback <Function> Функция обратного вызова, которая вызывается с пользовательским вводом в ответ на query.

Метод rl.question() выводит query, записывая его в output, ожидает ввода пользователя в input, а затем вызывает функцию callback, передавая полученный ввод в качестве первого аргумента.

При вызове rl.question() возобновит поток input, если он был приостановлен.

Если readline.Interface был создан с параметром output, установленным в null или undefined, query не выводится.

Функция callback, переданная в rl.question(), не следует обычному шаблону, при котором первым аргументом принимается объект Error или null. Функция callback вызывается только с переданным ответом в качестве аргумента.

При вызове rl.question() после rl.close() будет выброшена ошибка.

Пример использования:

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

Использование AbortController для отмены вопроса.

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); copy

readline.clearLine(stream, dir[, callback])

• stream <stream.Writable>
• dir <number>
  • -1: слева от курсора
  • 1: справа от курсора
  • 0: вся строка
• callback <Function> Вызывается после завершения операции.
• Возвращает: <boolean> false, если stream ожидает, что вызывающий код дождётся генерации события 'drain', прежде чем продолжить запись дополнительных данных; в противном случае — true.

Метод readline.clearLine() очищает текущую строку заданного потока TTY в направлении, указанном dir.

readline.clearScreenDown(stream[, callback])

• stream <stream.Writable>
• callback <Function> Вызывается после завершения операции.
• Возвращает: <boolean> false, если stream ожидает, что вызывающий код дождётся генерации события 'drain', прежде чем продолжить запись дополнительных данных; в противном случае — true.

Метод readline.clearScreenDown() очищает заданный поток TTY от текущего положения курсора вниз.

readline.createInterface(options)

• options <Object>
  • input <stream.Readable> Поток Readable, на котором нужно отслеживать события. Этот параметр обязателен.
  • output <stream.Writable> Поток Writable, в который записываются данные readline.
  • completer <Function> Необязательная функция для автодополнения по клавише Tab.
  • terminal <boolean> true, если потоки input и output следует обрабатывать как TTY и записывать в них управляющие последовательности ANSI/VT100. По умолчанию: проверка isTTY в потоке output при создании экземпляра.
  • history <string[]> Начальный список строк истории. Этот параметр имеет смысл только в том случае, если пользователь или внутренняя проверка output установили terminal в true; в противном случае механизм кэширования истории вообще не инициализируется. По умолчанию: [].
  • historySize <number> Максимальное количество сохраняемых строк истории. Чтобы отключить историю, установите это значение в 0. Этот параметр имеет смысл только в том случае, если пользователь или внутренняя проверка output установили terminal в true; в противном случае механизм кэширования истории вообще не инициализируется. По умолчанию: 30.
  • removeHistoryDuplicates <boolean> Если true, при добавлении в историю новой строки ввода, дублирующей более старую, старая строка удаляется из списка. По умолчанию: false.
  • prompt <string> Строка приглашения. По умолчанию: '> '.
  • crlfDelay <number> Если задержка между \r и \n превышает crlfDelay миллисекунд, \r и \n будут обрабатываться как отдельные символы конца строки. Значение crlfDelay будет приведено к числу, не меньшему 100. Можно задать значение Infinity; в этом случае \r, за которым следует \n, всегда будет считаться одним символом новой строки (это может быть полезно при чтении файлов с разделителем строк \r\n). По умолчанию: 100.
  • escapeCodeTimeout <number> Время, в течение которого readline ожидает символ (при чтении неоднозначной последовательности клавиш, которая на основании уже прочитанного ввода может как образовать полную последовательность клавиш, так и потребовать дополнительного ввода для завершения более длинной последовательности), в миллисекундах. По умолчанию: 500.
  • tabSize <integer> Количество пробелов, соответствующее символу табуляции (минимум 1). По умолчанию: 8.
  • signal <AbortSignal> Позволяет закрыть интерфейс с помощью AbortSignal. Прерывание сигнала внутренним образом вызывает close для интерфейса.
• Возвращает: <readline.Interface>

Метод readline.createInterface() создает новый экземпляр readline.Interface.

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

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

После создания экземпляра readline.Interface чаще всего подписываются на событие 'line':

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

Если для этого экземпляра terminal имеет значение true, поток output будет наиболее совместимым, если в нем определено свойство output.columns и генерируется событие 'resize' при изменении количества столбцов в output (ссылка process.stdout делает это автоматически, если она является TTY).

При создании readline.Interface с использованием stdin в качестве входных данных программа не завершится, пока не получит символ EOF. Чтобы выйти, не дожидаясь ввода пользователя, вызовите process.stdin.unref().

Использование функции completer

Функция completer принимает в качестве аргумента текущую строку, введенную пользователем, и возвращает Array из двух элементов:

• Array с подходящими вариантами автодополнения.
• Подстроку, использованную для поиска совпадений.

Например: [[substr1, substr2, ...], originalsubstring].

function completer(line) {
  const completions = '.help .error .exit .quit .q'.split(' ');
  const hits = completions.filter((c) => c.startsWith(line));
  // Show all completions if none found
  return [hits.length ? hits : completions, line];
} copy

Функцию completer можно вызывать асинхронно, если она принимает два аргумента:

function completer(linePartial, callback) {
  callback(null, [['123'], linePartial]);
} copy

readline.cursorTo(stream, x[, y][, callback])

• stream <stream.Writable>
• x <number>
• y <number>
• callback <Function> Вызывается после завершения операции.
• Возвращает: <boolean> false, если stream ожидает, что вызывающий код дождётся генерации события 'drain', прежде чем продолжить запись дополнительных данных; в противном случае — true.

Метод readline.cursorTo() перемещает курсор в указанное положение в заданном потоке TTY stream.

readline.moveCursor(stream, dx, dy[, callback])

• stream <stream.Writable>
• dx <number>
• dy <number>
• callback <Function> Вызывается после завершения операции.
• Возвращает: <boolean> false, если stream ожидает, что вызывающий код дождётся генерации события 'drain', прежде чем продолжить запись дополнительных данных; в противном случае — true.

Метод readline.moveCursor() перемещает курсор относительно его текущего положения в заданном потоке TTY stream.

readline.emitKeypressEvents(stream[, interface])

• stream <stream.Readable>
• interface <readline.InterfaceConstructor>

Метод readline.emitKeypressEvents() заставляет заданный поток Readable начать генерировать события 'keypress', соответствующие полученным данным.

Необязательный параметр interface задает экземпляр readline.Interface, для которого автодополнение отключается при обнаружении вставленного копированием ввода.

Если stream является потоком TTY, он должен находиться в raw-режиме.

Этот метод автоматически вызывается любым экземпляром readline для его input, если input является терминалом. Закрытие экземпляра readline не останавливает генерацию событий 'keypress' потоком input.

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

Пример: простая CLI

В следующем примере показано использование класса readline.Interface для реализации небольшого интерфейса командной строки:

import { createInterface } from 'node:readline';
import { exit, stdin, stdout } from 'node:process';
const rl = createInterface({
  input: stdin,
  output: 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!');
  exit(0);
});

const { createInterface } = require('node:readline');
const rl = 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);
});

Пример: построчное чтение потока файла

Часто readline используют для чтения входного файла по одной строке за раз. Проще всего это сделать с помощью API fs.ReadStream и цикла for await...of:

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

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

  const rl = 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();

const { createReadStream } = require('node:fs');
const { createInterface } = require('node:readline');

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

  const rl = 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();

В качестве альтернативы можно использовать событие 'line':

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

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

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

const { createReadStream } = require('node:fs');
const { createInterface } = require('node:readline');

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

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

В настоящее время цикл for await...of может работать немного медленнее. Если важны и поток async / await, и скорость, можно применить смешанный подход:

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

const { once } = require('node:events');
const { createReadStream } = require('node:fs');
const { createInterface } = require('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);
  }
})();

Сочетания клавиш TTY