javascript - 如何暂时用新的 rl.qu/estion 覆盖之前的 rl.qu/estion？

Question

注意:我对“qu/estion”表示歉意，但是 stackoverflow 阻止我在标题中添加“问题”。

如何用一个可以解决的新问题临时覆盖之前提出的 rl.question ，并且旧问题可以返回？这是一个例子:

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

function log(message) {
  readline.cursorTo(process.stdout, 0)
  console.log(message)

  rl.prompt(true)
}

function ask() {
  rl.question('> ', async function(answer) {
    log(answer)
    if (answer === 'testfunc') {
      await test()
    }
    ask()
  })
}

async function test() {
  await setTimeout(() => {
    log('Attempting')
    rl.question('can you see this? > ', function(answer) {
      log('This answer: ' + answer)
    })
  }, 3000)
}

ask()

log + ask() 函数允许使用某种进程内命令行，让您始终在输出底部有 > 并始终能够访问命令。

我有一个函数，test()，它是异步的，它想问自己的问题。我希望这个异步函数中的问题暂时覆盖“永久”问题，直到给出答案，然后“永久”问题才能获得优先权。

目前，这种行为有点有趣。乍一看，第二个问题似乎没有任何作用，但是如果您在 3 秒等待时间发生之前输入几个字母，您会看到光标移回行首，但它没有其他真实效果。

编辑:我确实希望主 rl.question 在异步函数运行时可用，除非在异步函数中询问 rl.question 时。

编辑 2:预期行为

1)你可以在主要的ask()问题中写任何东西，它就会重复。

2) 如果你编写 testfunc，它将转到主要的 Ask() 问题，并允许你输入它，直到 testfunc 上的 3 秒完成。

3)此后，testfunc的rl.question将触发并覆盖主要问题。

4) 一旦 testfunc 的问题得到解答，异步函数可以在需要时继续，并且主要的 Ask() 问题仍然可用。

Answer 1

我相信你提到了核心readline Node 包。它似乎需要回调，因此如果您遵循 promise ( async - await 方式)，则需要多次定义事件监听器回调。

所以首先你可以从 promise rl.question() 开始功能。一种方法可能是。

var rlQuestion = q => new Promise(v => rl.question(q, a => (rl.close() , v(a))));

只有这样你才会喜欢

var answer = await rlQuestion('What do you think of Node.js? ');

好的...这里我们继续讨论一些进一步的细节。 await 之后的函数命令应该返回一个 promise 。所以折射你的your codebin code进入如下所示的内容，我相信您现在应该能够更好地了解它是如何工作的。

const readline = require("readline"),
      rl       = readline.createInterface({ input : process.stdin,
                                            output: process.stdout
                                            }),
      rlq      = q => new Promise(v => rl.question(q, a => v(a))),
      log      = (...m) => {readline.cursorTo(process.stdout,0);
                            console.log(...m);
                            rl.prompt(true);};
async function test(){
  return new Promise(v => setTimeout(async function(){
                                             log("Attempting");
                                             let answer = await rlq("Can you see this? >");
                                             log("Answer: " + answer);
                                             v(answer);
                                           }, 3000));
}

async function ask(){
  let answer = await rlq("> ");
  answer = await (answer === "testfunc" ? test()
                                        : Promise.resolve(answer));
  log("ender ", answer);
  /^q$|^quit$/i.test(answer) ? log("bye..!"): ask(); // the "test" function here is RegExp.test..!}
}
ask();

根据您的评论进行编辑；

据我了解，异步函数(当前模拟需要 3 秒)可能会无限期地持续更长的时间，在此期间您希望提示正确返回。那么显然您正在处理两个单独的异步时间线(一个用于正常控制台输入，第二个是可能需要未知时间量的异步过程)，其中两个时间线都针对相同的入口点。

从 test() 开始，这个问题就存在了函数完成并调用rlq ( promise rl.question)任务ask()函数的rlq任务已经位于微任务队列的头部(Promise 的事件循环)并且 test()不会出现功能提示。你必须摆脱 ask()问题rlq任务。

输入rl.close() 。因此，首先我们关闭 readline 接口(interface)，然后在测试函数中重新创建它。顺便说一下，因为我们重新分配了 rl它不能再被定义为 const但是var .

看看以下内容是否适合您。

var readline = require("readline"),
    rl       = readline.createInterface({ input : process.stdin,
                                          output: process.stdout
                                        }),
    rlq      = q => new Promise(v => rl.question(q, a => v(a))),
    log      = (...m) => {readline.cursorTo(process.stdout,0);
                          console.log(...m);
                          rl.prompt(true);},
    test     = _ => setTimeout(async function(){
                                       log("Attempting");
                                       rl.close();
                                       rl = readline.createInterface({ input : process.stdin,
                                                                       output: process.stdout
                                                                     });
                                       var answer = await rlq("Can you see this? >");
                                       log(`Here i do something with ${answer} inside the test function`);
                                       ask();
                                     }, 3000);

async function ask(){
  let answer = await rlq("> ");
  answer === "testfunc" ? test()
                        : log(`Here i do something with ${answer}`);
  /^q$|^quit$/i.test(answer) ? (log("bye..!"), rl.close())
                             : ask(); // the "test" function here is RegExp.test..!}
}
ask();