如何在 node.js 中超时 fs.read

我尝试使用 fs.read 从文件描述符中读取。调用回调函数在它获得数据之后。它工作正常。

但是现在我想实现一个超时机制：如果 fs.read 在超时内没有获取数据，它应该停止读取。

如何告诉 fs.read 停止阅读？它仍然挂在后台试图阅读。

我大致执行以下操作：

...
var fd = fs.openSync("/dev/ttyUSB0", 'rs+');
...
...
var bout = new Buffer(string,'binary');
fs.write(fd, bout, 0, bout.length,undefined,function(err, written, buffer) {
  console.log("error writing: "+err);
  var bin = new Buffer(1);
  fs.read(fd,bin,0,1,undefined,function(err,read,buffer) {
    console.log("got it: "+bin);
  });
});
...
...

我想写一些东西到/dev/ttyUSB0 并阅读答案，但有时没有答案。如果发生这种情况，读取应超时，以便我可以开始另一次写入/读取。

谢谢

我尝试使用超时并关闭它，但它不起作用，这是一个例子：您必须为测试制作"mkfifo文件"。

var fs=require('fs');
console.log("open file");
fs.open('file', 'r+', function(err,fd) {
  console.log("start reading on "+fd);
  var length=5;
  var data = new Buffer(length);
  data.fill("-");
  setTimeout(function(){
    console.log("timeout");
    console.log("close fd "+fd);
    fs.close(fd,function(err) {
      console.log("close done: "+err);
    });
  }, 5000);
  fs.read(fd, data, 0, length,undefined, function(error, got) {
    console.log("error: "+error);
    console.log("got callback: "+data);
  });
  console.log("done");
});

fs.close 不起作用。关闭后，您可以制作"回显测试>文件"，然后读取获取数据。在关闭的文件句柄上读取？

知道吗？

另一种

方法是利用child_process.exec固有的timeout参数。这个想法是将fs.read方法放在一个单独的文件中，并从主进程作为单独的 shell 进程执行它。以下是您可以做到这一点的方法：

1-创建一个read.js脚本，其中包含：

var fs = require('fs');
fs.readFile('/etc/passwd', function (err, data) {
  if (err) throw err;
  process.send(data);
});

2-在主脚本中，执行read.js，然后等待其消息。

var exec = require('child_process').exec,
    child;
child = exec('node read.js',
  { timeout : 5000 }, //5 sec timeout
  function (error, stdout, stderr) {...}
});
child.on('message', function(data) {
  console.log(data);
});

正如其他人所提到的，您无法取消读取，因此您能做的最好的事情就是自己创建一个超时，并在完成后丢弃结果。

fs.read(..., timeout(1000, function(err, result){
}));
function timeout(time, cb){
  var called = false;
  var timer = setTimeout(function(){
    // If the timer finishes before the function is called,
    // then run the callback with an error. 
    if (!called){
       called = true;
       cb(new Error("Function timed out."));
    }
  }, time);
  return function(){
    // If the read finishes before the timer, cancel the timer
    // and call the original callback.
    if (!called){
      clearTimeout(timer);
      called = true;
      cb.apply(this, arguments);
    }
  };
});

您无法取消实际的读取操作。唯一的选择是设置计时器并从读取操作中取消订阅（使用 removeEventListener），然后通过调用具有自定义"超时"错误的原始事件处理程序来继续。

希望这有所帮助，如果您发布一些代码，我可以向您展示如何做到这一点。

var fs = require('fs');
var status = 0; // 0:start 1:fin
var timeout = 500;
fs.readFile('filename', function(err,data){
   status = 1
   console.log(data)
});
var timer = setTimeout(function(){
  clearTimeout(timer);
  if(!status){
    throw new Error('timeout');
  }
}, timeout);

对于不提供本机超时功能的函数（如 fs.stat、fs.read 等），您可以使用类似 callback-timeout 模块的内容来包装回调。

你可以做

const timeout = require('callback-timeout');
const fs = require('fs');
fs.stat('/mnt/never-returns', timeout((err, stats)=>{
   if(err) throw err;
   //happy with stats
}, 2000, 'fs.stat did not return in 2 secs'));

fs.readSync with timeout，使用 child_process.spawnSync 调用 dd

拨打dd（最大 RSS 4 MB）比拨打node（最大 RSS 40 MB）便宜

在 Windows 上，这可能适用于 busybox dd

// readWithTimeout.js
const child_process = require('child_process');
const fs = require('fs');
/**
* read with timeout. unix only
* @param {number | string} fdOrPath
* @param {number} blockSize
* @param {number} timeout
* @param {Object} options
* @param {number} [options.numBlocks=1]
* @param {string=} options.encoding
*/
function readWithTimeout(fdOrPath, blockSize, timeout, options = {}) {
  if (!options) options = {};
  const numBlocks = options.numBlocks || 1;
  if (options.numBlocks) delete options.numBlocks;
  if (options.timeout) throw Error('dont set options.timeout');
  const ddArgs = [`bs=${blockSize}`, `count=${numBlocks}`, 'status=none'];
  const stdio = [fdOrPath, 'pipe', 'pipe'];
  if (typeof fdOrPath == 'string') {
    if (!fs.existsSync(fdOrPath)) throw Error(`no such file: ${fdOrPath}`);
    ddArgs.push(`if=${fdOrPath}`);
    stdio[0] = null;
  }
  else if (typeof fdOrPath != 'number') {
    throw Error(`fdOrPath must be number or string`);
  }
  //console.dir({ fdOrPath, blockSize, timeout, stdio, ddArgs });
  const reader = child_process.spawnSync('dd', ddArgs, {
    timeout,
    stdio,
    windowsHide: true,
    ...options,
  });
  if (reader.error) throw reader.error;
  return reader.stdout;
}
// demo: read (1 byte) token from gnumake jobserver on fd 3
try {
  const readLen = 1;
  const output = readWithTimeout(3, 1, 1000, {
  //const output = readWithTimeout('/dev/null', 1, 1000, {
    encoding: 'utf8',
  });
  if (output.length == 0) {
    console.log(`read nothing`);
  }
  else if (output.length < readLen) {
    console.log(`read partial: ${output.length} of ${readLen} bytes`);
  }
  else {
    console.log('read ok');
  }
  console.dir(output);
}
catch (e) {
  if (e.errno == -110) {
    console.log('read error: timeout');
  }
  else {
    console.log('read error:');
    console.dir(e);
  }
}

# Makefile
# note: single space after $(.RECIPEPREFIX)
.RECIPEPREFIX := $(.RECIPEPREFIX) 
all:
  +node readWithTimeout.js
  +node readWithTimeout.js
  +node readWithTimeout.js
  +node readWithTimeout.js

$ make -j3
node readWithTimeout.js
read ok
'+'
node readWithTimeout.js
read ok
'+'
node readWithTimeout.js
read error: timeout
node readWithTimeout.js
read error: timeout
make: INTERNAL: Exiting with 1 jobserver tokens available; should be 3!

+node告诉 make 使用 make 作业服务器运行节点

make说"应该是3"，因为我们没有将令牌写回FD 4上的作业服务器

这是我的 Gnumake-tokenpool for JavaScript 的一部分

代码也处于读取超时状态

基于Verybadalloc的回答

相关内容

最新更新

热门标签：