コンソールから値をインタラクティブに読み取る
いくつかのコンソール拡張を備えた単純なサーバーhttpサーバーを作成することを考えました。コマンドラインデータから読み取るスニペットを見つけました。
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) { }ループを使用することはできませんか？また、質問時にサーバーが出力を受け取ると、回線が台無しになります。
「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() + "]");
});
この目的のために別の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
Readline APIは12分からかなり変更されました。ドキュメントは、標準ストリームからユーザー入力をキャプチャする便利な例を示しています。
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();
});
readline-sync を使用してください。これにより、コールバックがなくても同期コンソールを操作できます。パスワードでも動作します：
var favFood = read.question('What is your favorite food? ', {
hideEchoBack: true // The typed text on screen is hidden by `*` (default).
});Node == 7.xが使用されていると仮定すると、これは最新のasync-await回答に値すると思います。
答えはまだ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!
@robの回答はほとんどの場合に機能しますが、長い入力では期待どおりに機能しない場合があります。
それは代わりに使用すべきものです：
const stdin = process.openStdin();
let content = '';
stdin.addListener('data', d => {
content += d.toString();
});
stdin.addListener('end', () => {
console.info(`Input: ${content}`);
});
このソリューションが機能する理由の説明：
addListener('data')はバッファーのように機能し、コールバックがいっぱいになるか、入力が終了するとコールバックが呼び出されます。
長い入力はどうですか？単一の'data'コールバックでは十分ではないため、入力を2つ以上の部分に分割します。それはしばしば便利ではありません。
addListener('end')は、stdinリーダーが入力の読み取りを完了したときに通知します。以前のデータを保存していたので、今すぐすべてを読み取って処理できます。
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> 'の代わりに空の文字列を渡すことができます。
これは複雑すぎます。簡単なバージョン：
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 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
これに対する私のアプローチは、async generatorsを使用することです。
一連の質問があると仮定します。
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' ] ]
*/
readlineのブロックされていない動作のブロック/ Promiseを使用した代替ソリューション
Readline標準モジュールには「ブロックされていない」動作があるため、このコードは実行されないことがわかっているため、コンソールから3つの質問に答えることを想像してください。各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)
*提案されたソリューションはPromiseを使用しているため、最初の質問に回答がある場合にのみ2番目の質問を処理します。
'use strict';
var questionaire=[['First Question: ',null],['Second Question: ',null],['Third Question: ',null]];
function askaquestion(p_questionaire,p_i) {
p_questionaire[p_i][1] = new Promise(function (resolve,reject){
const readline = require('readline');
const rl = readline.createInterface(
{input: process.stdin, output:process.stdout}
);
rl.question(p_questionaire[p_i][0], function(answer) {
//console.log(answer);
resolve(answer),reject('error');
rl.close();
});
});
p_questionaire[p_i][1].then(resolve=>{
if (p_i<p_questionaire.length-1) askaquestion(p_questionaire,p_i+1);
else console.log('Results: ',p_questionaire) });
};
askaquestion(questionaire,0);
実行中の出力：
>node test3.js
First Question: 1
Second Question: 2
Third Question: 3
Results: [ [ 'First Question: ', Promise { '1' } ],
[ 'Second Question: ', Promise { '2' } ],
[ 'Third Question: ', Promise { '3' } ] ]
ブロックされたreadlineのブロックされていない動作
Readline標準モジュールには「ブロックされていない」動作があるため、このコードは実行されないことがわかっているため、コンソールから3つの質問に答えることを想像してください。各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' ] ]
コマンドラインから入力を取得するNodeで "tic-tac-toe"ゲームを作成する必要があり、この基本的な非同期/待機ブロックコードを作成してトリックを実行しました。
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()