- assert断言
- async_hooks异步钩子
- async_hooks/context异步上下文
- buffer缓冲区
- C++插件
- C/C++插件(使用Node-API)
- C++嵌入器
- child_process子进程
- cluster集群
- CLI命令行
- console控制台
- Corepack核心包
- crypto加密
- crypto/webcrypto网络加密
- debugger调试器
- deprecation弃用
- dgram数据报
- diagnostics_channel诊断通道
- dns域名服务器
- domain域
- Error错误
- events事件触发器
- fs文件系统
- global全局变量
- http超文本传输协议
- http2超文本传输协议2.0
- https安全超文本传输协议
- inspector检查器
- Intl国际化
- module模块
- module/cjsCommonJS模块
- module/esmECMAScript模块
- module/package包模块
- net网络
- os操作系统
- path路径
- perf_hooks性能钩子
- permission权限
- policy安全策略
- process进程
- punycode域名代码
- querystring查询字符串
- readline逐行读取
- repl交互式解释器
- report诊断报告
- stream流
- stream/web网络流
- string_decoder字符串解码器
- test测试
- timers定时器
- tls安全传输层
- trace_events跟踪事件
- tty终端
- url网址
- util实用工具
- v8引擎
- vm虚拟机
- wasi网络汇编系统接口
- worker_threads工作线程
- zlib压缩
Node.js v16.19.1 文档
- Node.js 16.19.1
-
►
目录
- readline 逐行读取
Interface
类'close'
事件'line'
事件'history'
事件'pause'
事件'resume'
事件'SIGCONT'
事件'SIGINT'
事件'SIGTSTP'
事件rl.close()
rl.pause()
rl.prompt([preserveCursor])
rl.question(query[, options], callback)
rl.resume()
rl.setPrompt(prompt)
rl.getPrompt()
rl.write(data[, key])
rl[Symbol.asyncIterator]()
rl.line
rl.cursor
rl.getCursorPos()
readline.clearLine(stream, dir[, callback])
readline.clearScreenDown(stream[, callback])
readline.createInterface(options)
readline.cursorTo(stream, x[, y][, callback])
readline.emitKeypressEvents(stream[, interface])
readline.moveCursor(stream, dx, dy[, callback])
- 示例:微型 CLI
- 示例:逐行读取文件流
- TTY 快捷键
- readline 逐行读取
-
►
索引
- assert 断言
- async_hooks 异步钩子
- async_hooks/context 异步上下文
- buffer 缓冲区
- C++插件
- C/C++插件(使用Node-API)
- C++嵌入器
- child_process 子进程
- cluster 集群
- CLI 命令行
- console 控制台
- Corepack 核心包
- crypto 加密
- crypto/webcrypto 网络加密
- debugger 调试器
- deprecation 弃用
- dgram 数据报
- diagnostics_channel 诊断通道
- dns 域名服务器
- domain 域
- Error 错误
- events 事件触发器
- fs 文件系统
- global 全局变量
- http 超文本传输协议
- http2 超文本传输协议2.0
- https 安全超文本传输协议
- inspector 检查器
- Intl 国际化
- module 模块
- module/cjs CommonJS模块
- module/esm ECMAScript模块
- module/package 包模块
- net 网络
- os 操作系统
- path 路径
- perf_hooks 性能钩子
- permission 权限
- policy 安全策略
- process 进程
- punycode 域名代码
- querystring 查询字符串
- readline 逐行读取
- repl 交互式解释器
- report 诊断报告
- stream 流
- stream/web 网络流
- string_decoder 字符串解码器
- test 测试
- timers 定时器
- tls 安全传输层
- trace_events 跟踪事件
- tty 终端
- url 网址
- util 实用工具
- v8 引擎
- vm 虚拟机
- wasi 网络汇编系统接口
- worker_threads 工作线程
- zlib 压缩
- ► 其他版本
- 文档搜索
目录
- readline 逐行读取
Interface
类'close'
事件'line'
事件'history'
事件'pause'
事件'resume'
事件'SIGCONT'
事件'SIGINT'
事件'SIGTSTP'
事件rl.close()
rl.pause()
rl.prompt([preserveCursor])
rl.question(query[, options], callback)
rl.resume()
rl.setPrompt(prompt)
rl.getPrompt()
rl.write(data[, key])
rl[Symbol.asyncIterator]()
rl.line
rl.cursor
rl.getCursorPos()
readline.clearLine(stream, dir[, callback])
readline.clearScreenDown(stream[, callback])
readline.createInterface(options)
readline.cursorTo(stream, x[, y][, callback])
readline.emitKeypressEvents(stream[, interface])
readline.moveCursor(stream, dx, dy[, callback])
- 示例:微型 CLI
- 示例:逐行读取文件流
- TTY 快捷键
readline 逐行读取#
源代码: lib/readline.js
node:readline
模块提供了用于从可读流(例如 process.stdin
)每次一行地读取数据的接口。
可以使用以下方式访问它:
const readline = require('node:readline');
下面的简单示例阐明了 node:readline
模块的基本用法。
const readline = require('node:readline');
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
rl.question('What do you think of Node.js? ', (answer) => {
// TODO:记录答案到数据库中
console.log(`Thank you for your valuable feedback: ${answer}`);
rl.close();
});
一旦调用此代码,则 Node.js 应用程序将不会终止,直到 readline.Interface
关闭,因为接口在 input
流上等待接收数据。
Interface
类#
- 继承自: <EventEmitter>
readline.Interface
类的实例是使用 readline.createInterface()
方法构造的。
每个实例都与单个 input
可读流和单个 output
可写流相关联。
output
流用于打印到达并从 input
流中读取的用户输入的提示。
'close'
事件#
发生以下情况之一时会触发 'close'
事件:
rl.close()
方法被调用,readline.Interface
实例放弃了对input
和output
流的控制;input
流接收到它的'end'
事件;input
流接收 Ctrl+D 以发出传输结束(EOT)的信号;input
流接收 Ctrl+C 以发出SIGINT
信号,并且在readline.Interface
实例上没有注册'SIGINT'
事件监听器。
调用监听器函数时不传入任何参数。
一旦触发 'close'
事件,则 readline.Interface
实例就完成了。
'line'
事件#
每当 input
流接收到行尾输入(\n
、\r
或 \r\n
)时,则会触发 'line'
事件。
这通常发生在用户按下 回车 或 返回 时。
如果从流中读取了新数据并且该流在没有最终行尾标记的情况下结束,也会触发 'line'
事件。
使用包含单行接收输入的字符串调用监听器函数。
rl.on('line', (input) => {
console.log(`Received: ${input}`);
});
'history'
事件#
每当历史数组发生更改时,则会触发 'history'
事件。
使用包含历史数组的数组调用监听器函数。
它将反映由于 historySize
和 removeHistoryDuplicates
引起的所有更改、添加的行和删除的行。
主要目的是允许监听器保留历史记录。 监听器也可以更改历史对象。 这可能有助于防止将某些行添加到历史记录中,例如密码。
rl.on('history', (history) => {
console.log(`Received: ${history}`);
});
'pause'
事件#
发生以下情况之一时会触发 'pause'
事件:
调用监听器函数时不传入任何参数。
rl.on('pause', () => {
console.log('Readline paused.');
});
'resume'
事件#
每当 input
流恢复时,则会触发 'resume'
事件。
调用监听器函数时不传入任何参数。
rl.on('resume', () => {
console.log('Readline resumed.');
});
'SIGCONT'
事件#
当之前使用 Ctrl+Z(即 SIGTSTP
)移动到后台的 Node.js 进程然后使用 fg(1p)
返回到前台时,则会触发 'SIGCONT'
事件。
如果 input
流在 SIGTSTP
请求之前暂停,则不会触发此事件。
调用监听器函数时不传入任何参数。
rl.on('SIGCONT', () => {
// `prompt` 会自动恢复流
rl.prompt();
});
Windows 不支持 'SIGCONT'
事件。
'SIGINT'
事件#
每当 input
流接收到 Ctrl+C 输入(通常称为 SIGINT
)时,则会触发 '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();
});
});
'SIGTSTP'
事件#
当 input
流接收到 Ctrl+Z 输入(通常称为 SIGTSTP
)时,则会触发 'SIGTSTP'
事件。
如果 input
流接收到 SIGTSTP
时没有注册 'SIGTSTP'
事件监听器,则 Node.js 进程将被发送到后台。
当使用 fg(1p)
恢复程序时,则将触发 'pause'
和 'SIGCONT'
事件。
这些可用于恢复 input
流。
如果 input
在进程发送到后台之前暂停,则不会触发 'pause'
和 'SIGCONT'
事件。
调用监听器函数时不传入任何参数。
rl.on('SIGTSTP', () => {
// 这将覆盖 SIGTSTP
// 并且阻止程序进入后台。
console.log('Caught SIGTSTP.');
});
Windows 不支持 'SIGTSTP'
事件。
rl.close()
#
rl.close()
方法关闭 readline.Interface
实例并放弃对 input
和 output
流的控制。
当调用时,将触发 'close'
事件。
调用 rl.close()
不会立即阻止其他由 readline.Interface
实例触发的事件(包括 'line'
)。
rl.pause()
#
rl.pause()
方法暂停 input
流,允许它稍后在必要时恢复。
调用 rl.pause()
不会立即暂停其他由 readline.Interface
实例触发的事件(包括 'line'
)。
rl.prompt([preserveCursor])
#
preserveCursor
<boolean> 如果为true
,则防止光标位置重置为0
。
rl.prompt()
方法将配置为 prompt
的 readline.Interface
实例写入 output
中的新行,以便为用户提供用于提供输入的新位置。
当调用时,如果 rl.prompt()
流已暂停,则 rl.prompt()
将恢复 input
流。
如果 readline.Interface
是在 output
设置为 null
或 undefined
的情况下创建的,则不会写入提示。
rl.question(query[, options], callback)
#
query
<string> 要写入output
的语句或查询,位于提示之前。options
<Object>signal
<AbortSignal> 可选择允许使用AbortController
取消question()
。
callback
<Function> 使用用户输入调用的回调函数以响应query
。
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.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);
如果此方法被调用为 util.promisify() 的版本,则它会返回使用答案履行的 Promise。
如果使用 AbortController
取消问题,则它将使用 AbortError
拒绝。
const util = require('node:util');
const question = util.promisify(rl.question).bind(rl);
async function questionExample() {
try {
const answer = await question('What is you favorite food? ');
console.log(`Oh, so your favorite food is ${answer}`);
} catch (err) {
console.error('Question rejected', err);
}
}
questionExample();
rl.resume()
#
如果 input
流已暂停,则 rl.resume()
方法会恢复该流。
rl.setPrompt(prompt)
#
prompt
<string>
rl.setPrompt()
方法设置了在调用 rl.prompt()
时将写入 output
的提示。
rl.getPrompt()
#
- 返回: <string> 当前的提示字符串
rl.getPrompt()
方法返回 rl.prompt()
使用的当前提示。
rl.write(data[, key])
#
rl.write()
方法会将 data
或由 key
标识的键序列写入 output
。
仅当 output
是 TTY 文本终端时才支持 key
参数。
有关组合键的列表,请参阅 TTY 快捷键。
如果指定了 key
,则忽略 data
。
当调用时,如果 rl.write()
流已暂停,则 rl.write()
将恢复 input
流。
如果 readline.Interface
是在 output
设置为 null
或 undefined
的情况下创建的,则不会写入 data
和 key
。
rl.write('Delete this!');
// 模拟 Ctrl+U 删除之前写的行
rl.write(null, { ctrl: true, name: 'u' });
rl.write()
方法将数据写入 readline
Interface
的 input
,就好像它是由用户提供的一样。
rl[Symbol.asyncIterator]()
#
- 返回: <AsyncIterator>
创建 AsyncIterator
对象,该对象遍历输入流中的每一行作为字符串。
此方法允许通过 for await...of
循环异步迭代 readline.Interface
对象。
输入流中的错误不会被转发。
如果循环以 break
、throw
或 return
终止,则将调用 rl.close()
。
换句话说,迭代 readline.Interface
将始终完全消费输入流。
性能无法与传统的 'line'
事件 API 相提并论。
对于性能敏感的应用程序,请改用 'line'
。
async function processLineByLine() {
const rl = readline.createInterface({
// ...
});
for await (const line of rl) {
// 逐行读取输入中的每一行
// 都将在此处作为 `line` 连续可用。
}
}
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();
});
rl.cursor
#
相对于 rl.line
的光标位置。
当从 TTY 流读取输入时,这将跟踪当前光标在输入字符串中的位置。 光标的位置决定了在处理输入时将被修改的输入字符串部分,以及将呈现终端插入符号的列。
rl.getCursorPos()
#
返回光标相对于输入提示 + 字符串的实际位置。 长输入(换行)字符串以及多行提示都包含在计算中。
readline.clearLine(stream, dir[, callback])
#
stream
<stream.Writable>dir
<number>-1
: 从光标向左1
: 从光标向右0
: 整行
callback
<Function> 操作完成后调用。- 返回: <boolean> 如果
stream
希望调用代码在继续写入额外的数据之前等待'drain'
事件被触发,则为false
;否则为true
。
readline.clearLine()
方法在 dir
标识的指定方向上清除给定 TTY 流的当前行。
readline.clearScreenDown(stream[, callback])
#
stream
<stream.Writable>callback
<Function> 操作完成后调用。- 返回: <boolean> 如果
stream
希望调用代码在继续写入额外的数据之前等待'drain'
事件被触发,则为false
;否则为true
。
readline.clearScreenDown()
方法从光标的当前位置向下清除给定的 TTY 流。
readline.createInterface(options)
#
options
<Object>input
<stream.Readable> 要监听的可读流。 此选项是必需的。output
<stream.Writable> 要将逐行读取的数据写入的可写流。completer
<Function> 可选的用于制表符自动补全的函数。terminal
<boolean> 如果input
和output
流应该被视为终端,并且写入了 ANSI/VT100 转义码,则为true
。 默认值: 在实例化时检查output
流上的isTTY
。history
<string[]> 历史行的初始列表。 仅当terminal
由用户或内部的output
检查设置为true
时,此选项才有意义,否则历史缓存机制根本不会初始化。 默认值:[]
。historySize
<number> 保留的最大历史行数。 要禁用历史记录,则将此值设置为0
。 仅当terminal
由用户或内部的output
检查设置为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> 允许使用中止信号关闭接口。 中止信号将在内部调用接口上的close
。
- 返回: <readline.Interface>
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 函数的使用#
completer
函数将用户输入的当前行作为参数,并返回包含 2 个条目的 Array
:
- 使用匹配条目的
Array
补全。 - 用于匹配的子字符串。
例如:[[substr1, substr2, ...], originalsubstring]
。
function completer(line) {
const completions = '.help .error .exit .quit .q'.split(' ');
const hits = completions.filter((c) => c.startsWith(line));
// 如果没有找到,则显示所有补全
return [hits.length ? hits : completions, line];
}
如果 completer
函数接受两个参数,则可以异步地调用它:
function completer(linePartial, callback) {
callback(null, [['123'], linePartial]);
}
readline.cursorTo(stream, x[, y][, callback])
#
stream
<stream.Writable>x
<number>y
<number>callback
<Function> 操作完成后调用。- 返回: <boolean> 如果
stream
希望调用代码在继续写入额外的数据之前等待'drain'
事件被触发,则为false
;否则为true
。
readline.cursorTo()
方法将光标移动到给定的 TTY stream
中的指定位置。
readline.emitKeypressEvents(stream[, interface])
#
stream
<stream.Readable>interface
<readline.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);
readline.moveCursor(stream, dx, dy[, callback])
#
stream
<stream.Writable>dx
<number>dy
<number>callback
<Function> 操作完成后调用。- 返回: <boolean> 如果
stream
希望调用代码在继续写入额外的数据之前等待'drain'
事件被触发,则为false
;否则为true
。
readline.moveCursor()
方法相对于它在给定的 TTY stream
中的当前位置移动光标。
示例:微型 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);
});
示例:逐行读取文件流#
node: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
});
// 注意:使用 crlfDelay 选项
// 将 input.txt 中的所有 CR LF ('\r\n') 实例识别为单个换行符。
for await (const line of rl) {
// input.txt 中的每一行都将在此处作为 `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) => {
// 处理行。
});
await once(rl, 'close');
console.log('File processed.');
} catch (err) {
console.error(err);
}
})();
TTY 快捷键#
快捷键 | 描述 | 注意事项 |
---|---|---|
Ctrl+Shift+Backspace | 删除行左 | 不适用于 Linux、Mac 和 Windows |
Ctrl+Shift+Delete | 删除行右 | 不适用于 Mac |
Ctrl+C | 触发 SIGINT 或关闭逐行读取实例 |
|
Ctrl+H | 删除左边 | |
Ctrl+D | 如果当前行为空或 EOF,则向右删除或关闭逐行读取实例 | 不适用于 Windows |
Ctrl+U | 从当前位置删除到行首 | |
Ctrl+K | 从当前位置删除到行尾 | |
Ctrl+A | 转到行首 | |
Ctrl+E | 跳到行尾 | |
Ctrl+B | 后退一个字符 | |
Ctrl+F | 前进一个字符 | |
Ctrl+L | 清屏 | |
Ctrl+N | 下一个历史子项 | |
Ctrl+P | 上一个历史子项 | |
Ctrl+Z | 将正在运行的进程移到后台。
输入 fg 并按 回车键 返回。 |
不适用于 Windows |
Ctrl+W 或 Ctrl +退格键 | 向后删除到单词边界 | Ctrl+退格键 不适用于 Linux、Mac 和 Windows |
Ctrl+Delete | 向前删除到单词边界 | 不适用于 Mac |
Ctrl+左箭头 或 Meta+B | 左边的单词 | Ctrl+左箭头 不适用于 Mac |
Ctrl+右箭头 或 Meta+F | 右边的单词 | Ctrl+右箭头 不适用于 Mac |
Meta+D 或 Meta +删除键 | 删除右边的单词 | Meta+删除键 不适用于 Windows |
Meta+退格键 | 删除左边的单词 | 不适用于 Mac |