Lendo o valor do console, interativamente

Eu pensei em criar um servidor http simples com alguma extensão de console. Encontrei o trecho para ler os dados da linha de comando.

  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();

  });

bom fazer as perguntas repetidamente, não posso simplesmente usar o while(done) { }loop? Também bem, se o servidor receber saída no momento da pergunta, ele arruinará a linha.

você não pode fazer um loop "while (done)" porque isso exigiria bloqueio na entrada, algo que o node.js não gosta de fazer.

Em vez disso, configure um retorno de chamada a ser chamado sempre que algo for inserido:

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() + "]");
  });

Eu usei outra API para esse fim ..

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

Isso permite solicitar um loop até que a resposta seja right. Também fornece um pequeno console agradável. Você pode encontrar os detalhes em http://nodejs.org/api/readline.html#readline_example_tiny_cli

A API Readline mudou bastante desde os 12 '. Os documentos mostram um exemplo útil para capturar a entrada do usuário de um fluxo padrão:

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();
});

Mais informações aqui.

Acredito que isso mereça uma async-awaitresposta moderna , assumindo que o nó> = 7.x seja usado.

A resposta ainda usa, ReadLine::questionmas a envolve, para que while (done) {}seja possível, algo que o OP pergunta explicitamente.

var cl = readln.createInterface( process.stdin, process.stdout );
var question = function(q) {
    return new Promise( (res, rej) => {
        cl.question( q, answer => {
            res(answer);
        })
    });
};

e, em seguida, um exemplo de uso

(async function main() {
    var answer;
    while ( answer != 'yes' ) {
        answer = await question('Are you sure? ');
    }
    console.log( 'finally you are sure!');
})();

leva à seguinte conversa

Are you sure? no
Are you sure? no
Are you sure? yes
finally you are sure!

Por favor, use o readline-sync , isso permite que você trabalhe com o console síncrono sem hells de retorno de chamada. Até funciona com senhas:

var favFood = read.question('What is your favorite food? ', {
  hideEchoBack: true // The typed text on screen is hidden by `*` (default). 
});

A resposta do @rob funcionará na maioria das vezes, mas pode não funcionar como o esperado com entradas longas.

É isso que você deve usar:

const stdin = process.openStdin();
let content = '';

stdin.addListener('data', d => {
  content += d.toString();
});

stdin.addListener('end', () => {
  console.info(`Input: ${content}`);
});

Explicação sobre por que esta solução funciona:

addListener('data') funciona como um buffer, o retorno de chamada será chamado quando estiver cheio ou / e for o final da entrada.

E quanto a entradas longas? Um único 'data'retorno de chamada não será suficiente; portanto, você dividirá sua entrada em duas ou mais partes. Isso geralmente não é conveniente.

addListener('end')nos notificará quando o leitor stdin terminar de ler nossa entrada. Como armazenamos os dados anteriores, agora podemos ler e processar todos juntos.

Eu recomendo usar o Inquirer , pois ele fornece uma coleção de interfaces de usuário comuns da linha de comando interativa.

const inquirer = require('inquirer');

const questions = [{
  type: 'input',
  name: 'name',
  message: "What's your name?",
}];

const answers = await inquirer.prompt(questions);
console.log(answers);

Aqui está um exemplo:

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
})

Resultado:

Enter name: bob
Your name is: bob

Isso é muito complicado. Uma versão mais fácil de:

var rl = require('readline');
rl.createInterface... etc

seria usar

var rl = require('readline-sync');

então esperará quando você usar

rl.question('string');

então é mais fácil repetir. por exemplo:

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!');
}

Um caso de uso comum provavelmente seria o aplicativo exibir um prompt genérico e manipulá-lo em uma instrução switch.

Você pode obter um comportamento equivalente a um loop while usando uma função auxiliar que se chamaria no retorno de chamada:

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

Você pode passar uma string vazia em vez de 'app> 'se o seu aplicativo já imprimir algo na tela fora desse loop.

Minha abordagem para isso seria usar geradores assíncronos .

Supondo que você tenha uma série de perguntas:

 const questions = [
        "How are you today ?",
        "What are you working on ?",
        "What do you think of async generators ?",
    ]

Para usar a awaitpalavra - chave, você deve agrupar seu programa em um IIFE assíncrono.

(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)
})();

Resultados esperados:

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' ]

Se você deseja obter perguntas e respostas por completo, pode conseguir isso com uma modificação simples:

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' ] ]
   */

Eu tive que escrever um jogo "jogo da velha" no Node, que recebia informações da linha de comando e escrevi esse bloco de código básico assíncrono / à espera que fazia o truque.

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()

Bloqueando o comportamento desbloqueado da linha de leitura

Imagine que você tem três perguntas a serem respondidas no console, pois agora você sabe que esse código não será executado porque o módulo padrão readline possui um comportamento 'desbloqueado', dizendo que cada rl.question é um encadeamento independente, portanto esse código não será executado.

'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 );

Saída em execução:

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)

A solução proposta usa um emissor de eventos para sinalizar o final de um encadeamento de desbloqueio e inclui a lógica do loop e o final do programa em sua função de ouvinte.

'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

Saída em execução:

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' ] ]

Criei um pequeno script para o diretório de leitura e escrevi um novo nome de console para o arquivo (exemplo: 'name.txt') e o texto no arquivo.

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();
  }
});

A maneira mais fácil é usar o readline-sync

Ele processa uma por uma entrada e sai.

npm i readline-sync

por exemplo:

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)
}