node.js: readSync à partir de stdin?

Je n'ai aucune idée de quand cela a montré jusqu'mais c'est une étape utile vers l'avant: http://nodejs.org/api/readline.html

var readline = require('readline');

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

rl.on('line', function (cmd) {
  console.log('You just typed: '+cmd);
});

Maintenant, je peux en lecture ligne-à-un-temps à partir de stdin. Les jours heureux.

Après jouer avec ce pour un peu, j'ai trouvé la réponse:

process.stdin.resume();
var fs = require('fs');
var response = fs.readSync(process.stdin.fd, 100, 0, "utf8");
process.stdin.pause();

réponse sera un tableau à deux indices, le premier étant les données tapé dans la console et le second sera la longueur des données, y compris le caractère de saut de ligne.

Il était assez facile de déterminer quand vous console.log(process.stdin) qui énumère toutes les propriétés dont une intitulée fd qui est bien sûr le nom du premier paramètre pour fs.readSync()

Profitez-en!
😀

J'ai trouvé une bibliothèque qui doit être en mesure d'accomplir ce que vous avez besoin de: https://github.com/anseki/readline-sync

Ici est la mise en œuvre avec " asynchrone attendre`. Dans le code ci-dessous, l'entrée est prise à partir de l'entrée standard et après la réception de données de l'entrée standard est arrêté en attente de données à l'aide de processus.stdin.pause();`.

process.stdin.setEncoding('utf8');

//This function reads only one line on console synchronously. After pressing `enter` key the console will stop listening for data.
function readlineSync() {
    return new Promise((resolve, reject) => {
        process.stdin.resume();
        process.stdin.on('data', function (data) {
            process.stdin.pause(); //stops after one line reads
            resolve(data);
        });
    });
}

//entry point
async function main() {
    let inputLine1 = await readlineSync();
    console.log('inputLine1 = ', inputLine1);
    let inputLine2 = await readlineSync();
    console.log('inputLine2 = ', inputLine2);
    console.log('bye');
}

main();

J'ai utilisé cette solution de contournement sur le nœud 0.10.24/linux:

var fs = require("fs")
var fd = fs.openSync("/dev/stdin", "rs")
fs.readSync(fd, new Buffer(1), 0, 1)
fs.closeSync(fd)

Ce code attend en appuyant sur ENTRÉE. Il lit un caractère de la ligne, si l'utilisateur entre elle avant d'appuyer sur ENTRÉE. Les autres caractères seront restés dans le tampon de la console et sera lu lors des appels ultérieurs à readSync.

J'ai écrit ce module de lire une ligne à la fois à partir d'un fichier ou l'entrée standard. Le module est nommé comme line-reader qui expose une ES6 *Generator function pour effectuer une itération sur une ligne à la fois. voici un exemple de code(en caractères d'imprimerie) à partir de readme.md.

import { LineReader } from "line-reader"

//FromLine and ToLine are optional arguments
const filePathOrStdin = "path-to-file.txt" || process.stdin
const FromLine: number = 1 //default is 0
const ToLine: number = 5 //default is Infinity
const chunkSizeInBytes = 8 * 1024 //default is 64 * 1024

const list: IterableIterator<string> = LineReader(filePathOrStdin, FromLine, ToLine, chunkSizeInBytes)

//Call list.next to iterate over lines in a file
list.next()

//Iterating using a for..of loop
for (const item of list) {
   console.log(item)
}

En dehors de code ci-dessus, vous pouvez aussi jeter un oeil à src > tests dossier dans le repo.

Remarque:-

ligne-lecteur de module ne pas lire tous les trucs en mémoire au lieu de cela il utilise la fonction de générateur pour générer des lignes asynchrones ou de synchronisation.