类： InterfaceConstructor #

InterfaceConstructor 类的实例是使用 readlinePromises.createInterface() 或 readline.createInterface() 方法构造的。 每个实例都与单个 input 可读 流和单个 output 可写 流相关联。 output 流用于打印到达并从 input 流中读取的用户输入的提示。

事件： 'close' #

事件： 'line' #

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

事件： 'history' #

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

事件： 'pause' #

调用监听器函数时不传入任何参数。

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

事件： 'resume' #

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

事件： 'SIGCONT' #

'SIGCONT' 事件在 Node.js 进程先前使用移动到后台时触发 控制键 + Z 然后使用 fg(1p) 将（即 SIGTSTP ）带回前台。

如果 input 流在 SIGTSTP 请求之前暂停，则不会触发此事件。

调用监听器函数时不传入任何参数。

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

Windows 不支持 'SIGCONT' 事件。

事件： 'SIGINT' #

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

事件： 'SIGTSTP' #

当使用 fg(1p) 恢复程序时，则将触发 'pause' 和 'SIGCONT' 事件。 这些可用于恢复 input 流。

如果 input 在进程发送到后台之前暂停，则不会触发 'pause' 和 'SIGCONT' 事件。

调用监听器函数时不传入任何参数。

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

Windows 不支持 'SIGTSTP' 事件。

rl.close() #

rl.pause() #

rl.prompt([preserveCursor]) #

rl.prompt() 方法将配置为 prompt 的 InterfaceConstructor 实例写入 output 中的新行，以便为用户提供用于提供输入的新位置。

当调用时，如果 rl.prompt() 流已暂停，则 rl.prompt() 将恢复 input 流。

如果 InterfaceConstructor 是在 output 设置为 null 或 undefined 的情况下创建的，则不会写入提示。

rl.resume() #

rl.setPrompt(prompt) #

rl.setPrompt() 方法设置了在调用 rl.prompt() 时将写入 output 的提示。

rl.getPrompt() #

rl.getPrompt() 方法返回 rl.prompt() 使用的当前提示。

rl.write(data[, key]) #

rl.write() 方法会将 data 或由 key 标识的键序列写入 output 。 仅当 output 是 TTY 文本终端时才支持 key 参数。 有关组合键列表，请参阅 TTY 键绑定 。

如果指定了 key ，则忽略 data 。

当调用时，如果 rl.write() 流已暂停，则 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' }); 拷贝

rl.write() 方法会将数据写入 readline Interface 的 input ，就好像它是由用户提供的一样。

rl[Symbol.asyncIterator]() #

创建 AsyncIterator 对象，该对象遍历输入流中的每一行作为字符串。 此方法允许通过 for await...of 循环异步迭代 InterfaceConstructor 对象。

输入流中的错误不会被转发。

如果循环以 break 、 throw 或 return 终止，则将调用 rl.close() 。 换句话说，迭代 InterfaceConstructor 将始终完全消费输入流。

性能无法与传统的 'line' 事件 API 相提并论。 对于性能敏感的应用，请改用 '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`.
} 拷贝

readline.createInterface() 将在调用后开始使用输入流。 在接口创建和异步迭代之间进行异步操作可能会导致丢失行。

rl.line #

如果不使用 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();
}); 拷贝

rl.cursor #

相对于 rl.line 的光标位置。

当从 TTY 流读取输入时，这将跟踪当前光标在输入字符串中的位置。 光标的位置决定了在处理输入时将被修改的输入字符串部分，以及将渲染终端插入符号的列。

rl.getCursorPos() #

返回光标相对于输入提示 + 字符串的实际位置。 长输入（换行）字符串以及多行提示都包含在计算中。

Promises API #

类： readlinePromises.Interface #

readlinePromises.Interface 类的实例是使用 readlinePromises.createInterface() 方法构造的。 每个实例都与单个 input 可读 流和单个 output 可写 流相关联。 output 流用于打印到达并从 input 流中读取的用户输入的提示。

rl.question(query[, options]) #

rl.question() 方法通过将 query 写入 output 来显示 query ，等待在 input 上提供用户输入，然后调用 callback 函数，将提供的输入作为第一个参数传入。

当调用时，如果 rl.question() 流已暂停，则 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}`); 拷贝

使用 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}`); 拷贝

类： readlinePromises.Readline #

new readlinePromises.Readline(stream[, options]) #

rl.clearLine() 方法在待处理动作的内部列表中添加一个动作，该动作在 dir 标识的指定方向上清除关联 stream 的当前行。 调用 rl.commit() 看看这个方法的效果，除非 autoCommit: true 传给了构造函数。

rl.clearScreenDown() #

rl.commit() #

rl.commit() 方法将所有待处理的操作发送到关联的 stream 并清除待处理操作的内部列表。

rl.cursorTo(x[, y]) #

rl.cursorTo() 方法向待处理动作的内部列表添加一个动作，该动作将光标移动到相关 stream 中指定的位置。 调用 rl.commit() 看看这个方法的效果，除非 autoCommit: true 传给了构造函数。

rl.moveCursor(dx, dy) #

rl.moveCursor() 方法向待处理操作的内部列表添加一个操作，该操作将光标相对于关联的 stream 中的当前位置移动。 调用 rl.commit() 看看这个方法的效果，除非 autoCommit: true 传给了构造函数。

rl.rollback() #

readlinePromises.createInterface(options) #

readlinePromises.createInterface() 方法创建新的 readlinePromises.Interface 实例。

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

一旦创建了 readlinePromises.Interface 实例，则最常见的场景就是监听 'line' 事件：

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

如果此实例的 terminal 是 true ，则如果它定义了 output.columns 属性，并且如果或当列发生变化时（ process.stdout 会当其是终端时自动执行此操作）在 output 上触发 'resize' 事件，则 output 流将获得最佳的兼容性。

completer 函数的使用 #

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];
} 拷贝

completer 函数也可以返回 <Promise> ，或者是异步的：

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

回调接口 #

类： readline.Interface #

readline.Interface 类的实例是使用 readline.createInterface() 方法构造的。 每个实例都与单个 input 可读 流和单个 output 可写 流相关联。 output 流用于打印到达并从 input 流中读取的用户输入的提示。

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

rl.question() 方法通过将 query 写入 output 来显示 query ，等待在 input 上提供用户输入，然后调用 callback 函数，将提供的输入作为第一个参数传入。

当调用时，如果 rl.question() 流已暂停，则 rl.question() 将恢复 input 流。

如果 readline.Interface 是在 output 设置为 null 或 undefined 的情况下创建的，则不会写入 query 。

传给 rl.question() 的 callback 函数不遵循接受 Error 对象或 null 作为第一个参数的典型模式。 以提供的答案作为唯一参数调用 callback 。

在 rl.close() 之后调用 rl.question() 会报错。

用法示例：

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

使用 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); 拷贝

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

readline.clearLine() 方法在 dir 标识的指定方向上清除给定 TTY 流的当前行。

readline.clearScreenDown(stream[, callback]) #

readline.clearScreenDown() 方法从光标的当前位置向下清除给定的 TTY 流。

readline.createInterface(options) #

readline.createInterface() 方法创建新的 readline.Interface 实例。

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

一旦创建了 readline.Interface 实例，则最常见的场景就是监听 'line' 事件：

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

如果此实例的 terminal 是 true ，则如果它定义了 output.columns 属性，并且如果或当列发生变化时（ process.stdout 会当其是终端时自动执行此操作）在 output 上触发 'resize' 事件，则 output 流将获得最佳的兼容性。

当使用 stdin 作为输入创建 readline.Interface 时，程序将不会终止，直到它收到 EOF 字符 。 要在不等待用户输入的情况下退出，则调用 process.stdin.unref() 。

completer 函数的使用 #

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];
} 拷贝

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

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

readline.cursorTo() 方法将光标移动到给定的 TTY stream 中的指定位置。

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

readline.moveCursor() 方法将光标相对于其在给定 TTY stream 中的当前位置移动。

readline.emitKeypressEvents(stream[, interface]) #

readline.emitKeypressEvents() 方法使给定的 可读 流开始触发与接收到的输入相对应的 'keypress' 事件。

可选地， interface 指定 readline.Interface 实例，当检测到复制粘贴输入时禁用自动补齐。

如果 stream 是 TTY ，则它必须处于原始模式。

如果 input 是终端，则它会被其 input 上的任何逐行读取实例自动调用。 关闭 readline 实例不会阻止 input 触发 'keypress' 事件。

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

示例：微型 CLI #

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);
}); 拷贝

示例：逐行读取文件流 #

readline 的一个常见用例是每次一行地消费输入文件。 最简单的方式是利用 fs.ReadStream API 和 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(); 拷贝

或者，可以使用 '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}`);
}); 拷贝

目前， 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);
})(); 拷贝

TTY 键绑定 #