Класс: 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. Если нет обработчиков событий 'SIGINT' зарегистрированы, когда поток input получает 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. Если нет обработчиков событий 'SIGTSTP' зарегистрированы, когда поток input получает 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() записывает конфигурированные значения экземпляра InterfaceConstructor в новую строку в output, чтобы предоставить пользователю новое место для ввода.

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

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

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() записывает либо data, либо последовательность нажатий клавиш, определённую key, в output. Аргумент key поддерживается только для текстовых терминалов ТTY. См. Клавиши ТTY для списка комбинаций клавиш.

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

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

Если экземпляр InterfaceConstructor был создан с output установленным в null или undefined, 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 как будто они были предоставлены пользователем.

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

• <строка>

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

Это может быть полезно при сборе ввода из потока 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

• <число> | <undefined>

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

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

rl.getCursorPos()

• Возвращает: <Объект>
  • rows <число> строка приглашения, на которой сейчас находится курсор
  • cols <число> колонна экрана, на которой сейчас находится курсор

Возвращает реальное положение курсора относительно приглашения и строки ввода. В расчёты включены длинные строки ввода (перенос), а также приглашения с несколькими строками.

API промисов

Класс: readlinePromises.Interface

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

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

rl.question(query[, options])

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

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

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

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

Если вопрос вызывается после rl.close(), он возвращает отклоненное promise.

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

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 <Объект>
  • autoCommit <boolean> Если true, нет необходимости вызывать rl.commit().

rl.clearLine(dir)

• dir <целое число>
  • -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 <целое число>
• y <целое число>
• Возвращает: this

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

rl.moveCursor(dx, dy)

• dx <целое число>
• dy <целое число>
• Возвращает: this

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

rl.rollback()

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

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

readlinePromises.createInterface(options)

• options <Объект>
  • input <stream.Readable> Поток Readable для прослушивания. Этот параметр обязателен.
  • output <stream.Writable> Поток Writable для записи данных readline.
  • completer <Функция> Необязательная функция для автодополнения.
  • 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 <строка> Строка запроса. По умолчанию: '> '.
  • crlfDelay <число> Если задержка между \r и \n превышает crlfDelay миллисекунд, \r и \n будут обрабатываться как отдельный ввод конца строки. crlfDelay будет приведено к числу не меньше 100. Можно установить в Infinity, в этом случае \r и \n всегда будут рассматриваться как одна новая строка (что может быть уместно для чтения файлов с разделителем строк \r\n). По умолчанию: 100.
  • escapeCodeTimeout <число> Длительность ожидания readlinePromises символа (при чтении неоднозначной последовательности клавиш, которая может как сформировать полную последовательность клавиш с уже прочитанным вводом, так и потребовать дополнительного ввода для завершения более длинной последовательности клавиш) в миллисекундах. По умолчанию: 500.
  • tabSize <целое> Количество пробелов, равное одной табуляции (минимум 1). По умолчанию: 8.
• Возвращает: <readlinePromises.Interface>

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

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

После создания экземпляра 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 с 2 элементами:

• 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(). Каждый экземпляр связан с одним потоком input Readable и одним потоком output Writable. Поток output используется для вывода приглашений для ввода пользователя, который поступает и считывается из потока input.

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

• query <строка> Оператор или запрос, который необходимо записать в output, добавляется перед приглашением.
• options <Объект>
  • signal <AbortSignal> Допускает отмену question() с помощью AbortController.
• callback <Функция> Функция обратного вызова, которая вызывается с вводом пользователя в ответ на 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 <число>
  • -1: слева от курсора
  • 1: справа от курсора
  • 0: вся строка
• callback <Функция> Вызывается по завершении операции.
• Возвращает: <логическое> false если stream хочет, чтобы вызывающий код ожидал события 'drain' перед продолжением записи дополнительных данных; в противном случае true.

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

readline.clearScreenDown(stream[, callback])

• stream <stream.Writable>
• callback <Функция> Вызывается по завершении операции.
• Возвращает: <логическое> 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[]> Начальный список строк истории. Этот параметр имеет смысл только если 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> Длительность readline ожидания символа (при чтении неоднозначной последовательности клавиш, которая может как образовать полную последовательность клавиш, используя прочитанный ввод, так и потребовать дополнительного ввода для завершения более длинной последовательности клавиш) в миллисекундах. По умолчанию: 500.
  • tabSize <integer> Количество пробелов, соответствующих табуляции (минимум 1). По умолчанию: 8.
  • signal <AbortSignal> Позволяет закрыть интерфейс с помощью AbortSignal. Прерывание сигнала вызовет close в интерфейсе.
• Возвращает: <readline.Interface>

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

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

После создания экземпляра 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 не останавливает input от излучения событий 'keypress'.

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

Пример: Небольшой CLI

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

const readline = require('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);
}); copy

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

Распространённый случай использования readline — это потребление входного файла по одной строке за раз. Самый простой способ сделать это — использовать API fs.ReadStream и цикл for await...of.

const fs = require('node:fs');
const readline = require('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(); copy

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

const fs = require('node:fs');
const readline = require('node:readline');

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

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

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

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

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