我尝试使用 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 固有的
timeoutfs.read1- 创建一个
read.jsvar fs = require('fs');
fs.readFile('/etc/passwd', function (err, data) {
if (err) throw err;
process.send(data);
});
2- 在主脚本中，执行
read.jsvar 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);
});
您无法取消实际的读取操作。唯一的选择是设置一个计时器并取消订阅（使用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.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);
}
};
});
对于不提供本机超时功能的函数（如 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超时，使用child_process.spawnSync调用dd
致电
ddnode仅限unix。在 Windows 上，这可能适用于
busybox dd#!/usr/bin/env node
// 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 from fd 0 = stdin
// ./readWithTimeout.js # -> timeout
// echo 12 | ./readWithTimeout.js # -> '1'
try {
const readFd = 0; // stdin
const readLen = 1;
const readTimeout = 1000; // milliseconds
const output = readWithTimeout(readFd, readLen, readTimeout, {
//const output = readWithTimeout('/dev/null', readLen, readTimeout, {
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);
}
}
$ ./readWithTimeout.js
read error: timeout
$ echo 12 | ./readWithTimeout.js
read ok
{ output: '1' }
这是我的 javascript gnumake-tokenpool 的一部分
基于verybadalloc的回答