我想用一些控制台扩展来制作一个简单的服务器 http 服务器。我发现 sn-p 可以从命令行数据中读取。
var i = rl.createInterface(process.stdin, process.stdout, null);
i.question('Write your name: ', function(answer) {
console.log('Nice to meet you> ' + answer);
i.close();
process.stdin.destroy();
});
重复提问，我不能简单地使用while(done) { } 循环吗？同样，如果服务器在提问时收到输出，它会破坏线路。
【问题讨论】：
rl 你的意思是readline？
while(done)循环。
我相信这值得一个现代的async-await 答案，假设使用 node >= 7.x。
答案仍然使用ReadLine::question，但将其包装起来以便while (done) {} 成为可能，这是OP 明确询问的问题。
var cl = readln.createInterface( process.stdin, process.stdout );
var question = function(q) {
return new Promise( (res, rej) => {
cl.question( q, answer => {
res(answer);
})
});
};
然后是一个示例用法
(async function main() {
var answer;
while ( answer != 'yes' ) {
answer = await question('Are you sure? ');
}
console.log( 'finally you are sure!');
})();
导致以下对话
Are you sure? no
Are you sure? no
Are you sure? yes
finally you are sure!
编辑。为了正确结束输入，调用
cl.close();
在脚本的末尾。
【讨论】：
cl.close()。问候。
最简单的方法是使用 readline-sync
它会一一处理输入和输出。
npm i readline-sync
例如：
var firstPrompt = readlineSync.question('Are you sure want to initialize new db? This will drop whole database and create new one, Enter: (yes/no) ');
if (firstPrompt === 'yes') {
console.log('--firstPrompt--', firstPrompt)
startProcess()
} else if (firstPrompt === 'no') {
var secondPrompt = readlineSync.question('Do you want to modify migration?, Enter: (yes/no) ');
console.log('secondPrompt ', secondPrompt)
startAnother()
} else {
console.log('Invalid Input')
process.exit(0)
}
【讨论】：
require声明。没有理由忽略它。
我必须在 Node 中编写一个“井字游戏”，该游戏从命令行获取输入，并编写了这个基本的异步/等待代码块来解决问题。
const readline = require('readline')
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
async function getAnswer (prompt) {
const answer = await new Promise((resolve, reject) =>{
rl.question(`${prompt}\n`, (answer) => {
resolve(answer)
});
})
return answer
}
let done = false
const playGame = async () => {
let i = 1
let prompt = `Question #${i}, enter "q" to quit`
while (!done) {
i += 1
const answer = await getAnswer(prompt)
console.log(`${answer}`)
prompt = processAnswer(answer, i)
}
rl.close()
}
const processAnswer = (answer, i) => {
// this will be set depending on the answer
let prompt = `Question #${i}, enter "q" to quit`
// if answer === 'q', then quit
if (answer === 'q') {
console.log('User entered q to quit')
done = true
return
}
// parse answer
// if answer is invalid, return new prompt to reenter
// if answer is valid, process next move
// create next prompt
return prompt
}
playGame()
【讨论】：
这太复杂了。更简单的版本：
var rl = require('readline');
rl.createInterface... etc
会用
var rl = require('readline-sync');
然后它会在你使用时等待
rl.question('string');
然后更容易重复。 例如：
var rl = require('readline-sync');
for(let i=0;i<10;i++) {
var ans = rl.question('What\'s your favourite food?');
console.log('I like '+ans+' too!');
}
【讨论】：
我为读取目录创建了一个小脚本，并将控制台名称新文件（例如：'name.txt'）和文本写入文件。
const readline = require('readline');
const fs = require('fs');
const pathFile = fs.readdirSync('.');
const file = readline.createInterface({
input: process.stdin,
output: process.stdout
});
file.question('Insert name of your file? ', (f) => {
console.log('File is: ',f.toString().trim());
try{
file.question('Insert text of your file? ', (d) => {
console.log('Text is: ',d.toString().trim());
try {
if(f != ''){
if (fs.existsSync(f)) {
//file exists
console.log('file exist');
return file.close();
}else{
//save file
fs.writeFile(f, d, (err) => {
if (err) throw err;
console.log('The file has been saved!');
file.close();
});
}
}else{
//file empty
console.log('Not file is created!');
console.log(pathFile);
file.close();
}
} catch(err) {
console.error(err);
file.close();
}
});
}catch(err){
console.log(err);
file.close();
}
});
【讨论】：
我的方法是使用异步生成器。
假设您有一系列问题：
const questions = [
"How are you today ?",
"What are you working on ?",
"What do you think of async generators ?",
]
为了使用 await 关键字，您必须将程序包装到异步 IIFE 中。
(async () => {
questions[Symbol.asyncIterator] = async function * () {
const stdin = process.openStdin()
for (const q of this) {
// The promise won't be solved until you type something
const res = await new Promise((resolve, reject) => {
console.log(q)
stdin.addListener('data', data => {
resolve(data.toString())
reject('err')
});
})
yield [q, res];
}
};
for await (const res of questions) {
console.log(res)
}
process.exit(0)
})();
预期结果：
How are you today ?
good
[ 'How are you today ?', 'good\n' ]
What are you working on ?
:)
[ 'What are you working on ?', ':)\n' ]
What do you think about async generators ?
awesome
[ 'What do you think about async generators ?', 'awesome\n' ]
如果您想完全获得问题和答案，您可以通过简单的修改来实现：
const questionsAndAnswers = [];
for await (const res of questions) {
// console.log(res)
questionsAndAnswers.push(res)
}
console.log(questionsAndAnswers)
/*
[ [ 'How are you today ?', 'good\n' ],
[ 'What are you working on ?', ':)\n' ],
[ 'What do you think about async generators ?', 'awesome\n' ] ]
*/
【讨论】：
这是一个例子：
const stdin = process.openStdin()
process.stdout.write('Enter name: ')
stdin.addListener('data', text => {
const name = text.toString().trim()
console.log('Your name is: ' + name)
stdin.pause() // stop reading
})
输出：
Enter name: bob
Your name is: bob
【讨论】：
阻止 readline 未阻止的行为
假设您需要从控制台回答三个问题，因为您现在知道此代码不会运行，因为 readline 标准模块具有“未阻塞”行为，即每个 rl.question 都是独立线程，因此此代码不会运行。
'use strict';
var questionaire=[['First Question: ',''],['Second Question: ',''],['Third Question: ','']];
function askaquestion(question) {
const readline = require('readline');
const rl = readline.createInterface(
{input: process.stdin, output:process.stdout}
);
rl.question(question[0], function(answer) {
console.log(answer);
question[1] = answer;
rl.close();
});
};
var i=0;
for (i=0; i < questionaire.length; i++) {
askaquestion(questionaire[i]);
}
console.log('Results:',questionaire );
运行输出：
node test.js
Third Question: Results: [ [ 'First Question: ', '' ],
[ 'Second Question: ', '' ],
[ 'Third Question: ', '' ] ] <--- the last question remain unoverwritten and then the final line of the program is shown as the threads were running waiting for answers (see below)
aaa <--- I responded with a single 'a' that was sweeped by 3 running threads
a <--- Response of one thread
a <--- Response of another thread
a <--- Response of another thread (there is no order on threads exit)
建议的解决方案使用事件发射器来发出解除阻塞线程结束的信号，并将循环逻辑和程序结束包含在其侦听器函数中。
'use strict';
var questionaire=[['First Question: ',''],['Second Question: ',''],['Third Question: ','']];
// Introduce EventEmitter object
const EventEmitter = require('events');
class MyEmitter extends EventEmitter {};
const myEmitter = new MyEmitter();
myEmitter.on('continue', () => {
console.log('continue...');
i++; if (i< questionaire.length) askaquestion(questionaire[i],myEmitter); // add here relevant loop logic
else console.log('end of loop!\nResults:',questionaire );
});
//
function askaquestion(p_question,p_my_Emitter) { // add a parameter to include my_Emitter
const readline = require('readline');
const rl = readline.createInterface(
{input: process.stdin, output:process.stdout}
);
rl.question(p_question[0], function(answer) {
console.log(answer);
p_question[1] = answer;
rl.close();
myEmitter.emit('continue'); // Emit 'continue' event after the question was responded (detect end of unblocking thread)
});
};
/*var i=0;
for (i=0; i < questionaire.length; i++) {
askaquestion(questionaire[i],myEmitter);
}*/
var i=0;
askaquestion(questionaire[0],myEmitter); // entry point to the blocking loop
// console.log('Results:',questionaire ) <- moved to the truly end of the program
运行输出：
node test2.js
First Question: 1
1
continue...
Second Question: 2
2
continue...
Third Question: 3
3
continue...
done!
Results: [ [ 'First Question: ', '1' ],
[ 'Second Question: ', '2' ],
[ 'Third Question: ', '3' ] ]
【讨论】：
我推荐使用Inquirer，因为它提供了一组常用的交互式命令行用户界面。
const inquirer = require('inquirer');
const questions = [{
type: 'input',
name: 'name',
message: "What's your name?",
}];
const answers = await inquirer.prompt(questions);
console.log(answers);
【讨论】：
一个常见的用例可能是应用程序显示一个通用提示并在 switch 语句中处理它。
您可以通过使用会在回调中调用自身的辅助函数来获得与 while 循环等效的行为：
const readline = require('readline');
const rl = readline.createInterface(process.stdin, process.stdout);
function promptInput (prompt, handler)
{
rl.question(prompt, input =>
{
if (handler(input) !== false)
{
promptInput(prompt, handler);
}
else
{
rl.close();
}
});
}
promptInput('app> ', input =>
{
switch (input)
{
case 'my command':
// handle this command
break;
case 'exit':
console.log('Bye!');
return false;
}
});
如果您的应用已经在此循环之外在屏幕上打印了一些内容，您可以传递一个空字符串而不是 'app> '。
【讨论】：
请使用readline-sync，这让您可以使用同步控制台而无需回调地狱。甚至可以使用密码：
var favFood = read.question('What is your favorite food? ', {
hideEchoBack: true // The typed text on screen is hidden by `*` (default).
});【讨论】：
@rob answer 在大多数情况下都可以正常工作，但对于长输入，它可能无法按预期工作。
这就是你应该改用的：
const stdin = process.openStdin();
let content = '';
stdin.addListener('data', d => {
content += d.toString();
});
stdin.addListener('end', () => {
console.info(`Input: ${content}`);
});
解释为什么这个解决方案有效：
addListener('data') 像缓冲区一样工作，当它满了或/和输入结束时将调用回调。
长输入呢？单个'data' 回调是不够的，因此您会将输入分成两部分或更多部分。这通常不方便。
addListener('end') 将在标准输入读取器完成读取我们的输入时通知我们。由于我们一直在存储以前的数据，因此我们现在可以一起读取和处理它们。
【讨论】：
自 12 年以来，Readline API 发生了很大变化。该文档显示了一个从标准流中捕获用户输入的有用示例：
const readline = require('readline');
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
rl.question('What do you think of Node.js? ', (answer) => {
console.log('Thank you for your valuable feedback:', answer);
rl.close();
});
【讨论】：
我为此使用了另一个 API..
var readline = require('readline');
var rl = readline.createInterface(process.stdin, process.stdout);
rl.setPrompt('guess> ');
rl.prompt();
rl.on('line', function(line) {
if (line === "right") rl.close();
rl.prompt();
}).on('close',function(){
process.exit(0);
});
这允许循环提示，直到答案为right。它还提供了不错的小控制台。您可以找到详细信息@http://nodejs.org/api/readline.html#readline_example_tiny_cli
【讨论】：
您不能执行“while(done)”循环，因为这需要阻塞输入，这是 node.js 不喜欢做的事情。
而是设置每次输入内容时调用的回调：
var stdin = process.openStdin();
stdin.addListener("data", function(d) {
// note: d is an object, and when converted to a string it will
// end with a linefeed. so we (rather crudely) account for that
// with toString() and then trim()
console.log("you entered: [" +
d.toString().trim() + "]");
});
【讨论】：