node.js：从标准输入读取同步？

Question

是否可以从node.js中的stdin同步读取？因为我正在用 JavaScript 编写一个 Brainfuck 的 JavaScript 编译器（只是为了好玩）。 Brainfuck支持需要同步实现的读操作。

我尝试了这个：

const fs = require('fs');
var c = fs.readSync(0,1,null,'utf-8');
console.log('character: '+c+' ('+c.charCodeAt(0)+')');

但这只会产生这个输出：

fs:189
  var r = binding.read(fd, buffer, offset, length, position);
              ^
Error: EAGAIN, Resource temporarily unavailable
    at Object.readSync (fs:189:19)
    at Object.<anonymous> (/home/.../stdin.js:3:12)
    at Module._compile (module:426:23)
    at Module._loadScriptSync (module:436:8)
    at Module.loadSync (module:306:10)
    at Object.runMain (module:490:22)
    at node.js:254:10

Answer 1

您是否尝试过：

fs=require('fs');
console.log(fs.readFileSync('/dev/stdin').toString());

但是，它将等待读入整个文件，并且不会像 scanf 或 cin 那样在 \n 上返回。

Answer 2

经过一番摆弄后，我找到了答案：

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

响应将是一个具有两个索引的数组，第一个是输入到控制台的数据，第二个是包括换行符在内的数据长度。

当您使用 console.log(process.stdin) 枚举所有属性时，很容易确定，其中包括一个标记为 fd 的属性，它当然是第一个参数的名称对于 fs.readSync()

尽情享受吧！
：D

Answer 3

Marcus Pope 答案的更新版本从 node.js v0.10.4 开始运行：

请注意：

• 一般来说，node 的 流接口仍在不断变化（双关语半有意），并且截至 2 - 不稳定代码>node.js v0.10.4。
• 不同平台的行为略有不同；我研究过 OS X 10.8.3 和 Windows 7：主要区别是：同步读取交互式标准输入（通过在终端中逐行输入）仅适用于 Windows 7。

以下是更新后的代码，以 256 字节块的形式从标准输入同步读取，直到没有更多输入可用：

var fs = require('fs');
var BUFSIZE=256;
var buf = new Buffer(BUFSIZE);
var bytesRead;

while (true) { // Loop as long as stdin input is available.
    bytesRead = 0;
    try {
        bytesRead = fs.readSync(process.stdin.fd, buf, 0, BUFSIZE);
    } catch (e) {
        if (e.code === 'EAGAIN') { // 'resource temporarily unavailable'
            // Happens on OS X 10.8.3 (not Windows 7!), if there's no
            // stdin input - typically when invoking a script without any
            // input (for interactive stdin input).
            // If you were to just continue, you'd create a tight loop.
            throw 'ERROR: interactive stdin input not supported.';
        } else if (e.code === 'EOF') {
            // Happens on Windows 7, but not OS X 10.8.3:
            // simply signals the end of *piped* stdin input.
            break;          
        }
        throw e; // unexpected exception
    }
    if (bytesRead === 0) {
        // No more stdin input available.
        // OS X 10.8.3: regardless of input method, this is how the end 
        //   of input is signaled.
        // Windows 7: this is how the end of input is signaled for
        //   *interactive* stdin input.
        break;
    }
    // Process the chunk read.
    console.log('Bytes read: %s; content:\n%s', bytesRead, buf.toString(null, 0, bytesRead));
}

Answer 4

我不知道这是什么时候出现的，但这是向前迈出的有用的一步： 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);
});

现在我可以从标准输入中一次读取一行。快乐的日子。

Answer 5

我找到了一个应该能够满足您需要的库： https://github.com/anseki/readline -同步

Answer 6

重要提示： Node.js 贡献者刚刚通知我 .fd 未记录，用作内部调试目的的手段。因此，代码不应引用此文件，而应使用 fs.open/openSync 手动打开文件描述符。

在 Node.js 6 中，还值得注意的是，由于其不安全的性质，使用 new 通过其构造函数创建 Buffer 实例已被弃用。人们应该使用 Buffer.alloc 来代替：

'use strict';

const fs = require('fs');

// small because I'm only reading a few bytes
const BUFFER_LENGTH = 8;

const stdin = fs.openSync('/dev/stdin', 'rs');
const buffer = Buffer.alloc(BUFFER_LENGTH);

fs.readSync(stdin, buffer, 0, BUFFER_LENGTH);
console.log(buffer.toString());
fs.closeSync(stdin);

此外，应该只在必要时打开和关闭文件描述符；每次希望从 stdin 读取数据时都执行此操作会导致不必要的开销。

Answer 7

以下代码从 stdin 读取同步。读取输入直到出现换行符/回车键。该函数返回输入的字符串，并丢弃换行符 (\n) 和回车符 (\r)。这应该与 Windows、Linux 和 Mac OSX 兼容。添加了对 Buffer.alloc 的条件调用（new Buffer(size) 目前已弃用，但某些旧版本缺少 Buffer.alloc。

function prompt(){
    var fs = require("fs");

    var rtnval = "";

    var buffer = Buffer.alloc ? Buffer.alloc(1) : new Buffer(1);

    for(;;){
        fs.readSync(0, buffer, 0, 1);   //0 is fd for stdin
        if(buffer[0] === 10){   //LF \n   return on line feed
            break;
        }else if(buffer[0] !== 13){     //CR \r   skip carriage return
            rtnval += new String(buffer);
        }
    }

    return rtnval;
}

Answer 8

function read_stdinSync() {
    var b = new Buffer(1024)
    var data = ''

    while (true) {
        var n = fs.readSync(process.stdin.fd, b, 0, b.length)
        if (!n) break
        data += b.toString(null, 0, n)
    }
    return data
}

Answer 9

这是“async wait”的实现。在下面的代码中，输入从标准输入获取，接收数据后，标准输入通过使用“process.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();

Answer 10

我在节点 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)

此代码等待按 ENTER 键。如果用户在按 ENTER 键之前输入该字符，则它会从行中读取一个字符。其他字符将保留在控制台缓冲区中，并在后续调用 readSync 时读取。

Answer 11

我编写了这个 模块 来一次从文件或标准输入中读取一行。该模块被命名为line-reader，它公开了一个ES6 *Generator 函数来一次迭代一行。这是来自 readme.md 的代码示例（TypeScript 格式）。

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

除了上面的代码，你还可以看一下 src > repo 中的tests 文件夹。

注意：-
line-reader 模块不会将所有内容读取到内存中，而是使用生成器函数来生成行异步或同步。