CODEWITHSUNDEEP
node.jsstdinblocking
JoshuaJ
JoshuaJ

Reputation: 979

Block for stdin in Node.js

Short explanation:

I'm attempting to write a simple game in Node.js that needs to wait for user input every turn. How do I avoid callback hell (e.g. messy code) internal to a turn loop where each turn loop iteration needs to block and wait for input from stdin?

Long explanation:

All the explanations I have read on StackOverflow when someone asks about blocking for stdin input seem to be "that's not what Node.js is about!"

I understand that Node.js is designed to be non-blocking and I also understand why. However I feel that it has me stuck between a rock and a hard place on how to solve this. I feel like I have three options:

  1. Find a way to block for stdin and retain my while loop
  2. Ditch the while loop and instead recursively call a method (like nextTurn) whenever the previous turn ends.
  3. Ditch the while loop and instead use setTimeout(0, ...) or something similar to call a method (like nextTurn) whenever a turn ends.

With option (1) I am going against Node.js principles of non-blocking IO. With option (2) I will eventually reach a stack overflow as each call adds another turn to the call stack. With option (3) my code ends up being a mess to follow.

Internal to Node.js there are default functions that are marked **Sync (e.g. see the fs library or the sleep function) and I'm wondering why there is no Sync method for getting user input? And if I were to write something similar to fs.readSync how would I go about doing it and still follow best practices?

Upvotes: 6

Views: 7407

Answers (3)

marknuzz
marknuzz

Reputation: 2932

ArtHare's solution, at least for my use case, blocks background execution, including those started by a promise. While this code isn't elegant, it did block execution of the current function, until the read from stdin completed.

While this code must run from inside an async function, keep in mind that running an async function from a top-level context (directly from a script, not contained within any other function) will block that function until it completes.

Below is a full .js script demonstrating usage, tested with node v8.12.0: 

const readline = require('readline');
const sleep = (waitTimeInMs) => new Promise(resolve => setTimeout(resolve, waitTimeInMs));

async function blockReadLine() {

    var rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout,
        terminal: false
    });

    let result = undefined;
    rl.on('line', function(line){
        result = line;
    })

    while(!result) await sleep(100);

    return result;
}

async function run() {
    new Promise(async () => {
        while(true) {
            console.log("Won't be silenced! Won't be censored!");
            await sleep(1000);
        }
    });

    let result = await blockReadLine();
    console.log("The result was:" + result);
    process.exit(0);
}

run();

Upvotes: 1

ArtHare
ArtHare

Reputation: 1836

Just found this: https://www.npmjs.com/package/readline-sync

Example code (after doing an npm install readline-sync)

var readlineSync = require('readline-sync');
while(true) {
  var yn = readlineSync.question("Do you like having tools that let you code how you want, rather than how their authors wanted?");
  if(yn === 'y') {
    console.log("Hooray!");
  } else {
    console.log("Back to callback world, I guess...");
    process.exit();
  }
}

Only problem so far is the wailing of the "That's not how node is meant to be used!" chorus, but I have earplugs :)

Upvotes: 14

Timothy Strimple
Timothy Strimple

Reputation: 23070

I agree with the comment about moving towards an event based system and would ditch the loops. I've thrown together a quick example of text based processing which can be used for simple text games.

var fs = require('fs'),
    es = require('event-stream');

process.stdin
    .pipe(es.split())
    .on('data', parseCommand);

var actionHandlers = {};

function parseCommand(command) {
    var words = command.split(' '),
        action = '';

    if(words.length > 1) {
        action = words.shift();
    }

    if(actionHandlers[action]) {
        actionHandlers[action](words);
    } else {
        invalidAction(action);
    }
}

function invalidAction(action) {
    console.log('Unknown Action:', action);
}

actionHandlers['move'] = function(words) {
    console.log('You move', words);
}

actionHandlers['attack'] = function(words) {
    console.log('You attack', words);
}

You can now break up your actions into discrete functions which you can register with a central actionHandlers variable. This makes adding new commands almost trivial. If you can add some details on why the above approach wouldn't work well for you, let me know and I'll revise the answer.

Upvotes: 5

Related Questions