Javascript 如何在流中使用光纤

我正在尝试将光纤用于流：

var Fiber = require('fibers');
var Future = require('fibers/future');
var fs = require('fs');

function sleepForMs(ms) {
  var fiber = Fiber.current;
  setTimeout(function() {
    fiber.run();
  }, ms);
  Fiber.yield();
}

function catchError(f, onError) {
  return function () {
    var args = arguments;
    var run = function () {
      try {
        var ret = f.apply(null, args);
      }
      catch (e) {
        onError(e);
      }
      return ret;
    };
    if (Fiber.current) {
      return run();
    }
    else {
      return Fiber(run).run();
    }
  }
}

function processFile(callback) {
  var count, finished, onData, onException, onIgnoredEntry;
  count = 0;
  finished = false;
  onException = function (error) {
    if (finished) {
      console.error("Exception thrown after already finished:", error.stack || error);
    }
    if (finished) {
      return;
    }
    finished = true;
    return callback(error);
  };
  onData = function(data) {
    console.log("onData");
    if (finished) {
      return;
    }
    console.log("before sleep");
    sleepForMs(500);
    console.log("after sleep");
    throw new Error("test");
  };
  return fs.createReadStream('test.js').on('data', catchError(onData, onException)).on('end', function() {
    console.log("end");
    if (finished) {
      return;
    }
    finished = true;
    return callback(null, count);
  }).on('error', function(error) {
    console.log("error", error);
    if (finished) {
      return;
    }
    finished = true;
    return callback(error);
  });
};

Fiber(function () {
  console.log("Calling processFile");
  Future.wrap(processFile)().wait();
  console.log("processFile returned");
}).run();
console.log("back in main");

但它并没有真正起作用。数据回调在回调内的光纤完成之前完成。因此，上述代码输出：

Calling processFile
back in main
onData
before sleep
end
processFile returned
after sleep
Exception thrown after already finished: Error: test

事实上，它应该更像：

Calling processFile
back in main
onData
before sleep
after sleep
end
processFile returned
Error: test

---

下面是一个使用wait.for（光纤包装器）的实现

在这个实现中，为每个数据块启动一个光纤，因此并行启动“n”个任务。ProcessFile在所有光纤完成之前不会“返回”。

这是一个演示，演示了如何使用Fibers&wait.for实现这一点，但是在生产中使用它之前，当然应该将模块级变量和所有函数封装在一个类中

var wait = require('wait.for');
var fs = require('fs');

var tasksLaunched=0;
var finalCallback;
var callbackDone=false;
var dataArr=[]

function sleepForMs(ms,sleepCallback) {
  setTimeout(function() {
    return sleepCallback();
  }, ms);
}

function resultReady(err,data){

    if (err){
      callbackDone = true;
      return finalCallback(err);
    }

    dataArr.push(data);
    if (dataArr.length>=tasksLaunched && !callbackDone) {
      callbackDone = true;
      return finalCallback(null,dataArr);
    }
}

function processChunk(data,callback) {
    var ms=Math.floor(Math.random()*1000);
    console.log('waiting',ms);
    wait.for(sleepForMs,ms);
    console.log(data.length,"chars");
    return callback(null,data.length);
}

function processFile(filename,callback) {
  var count, onData, onException, onIgnoredEntry;
  count = 0;
  finalCallback = callback;

  onException = function (error) {
    if (!callbackDone){
      callbackDone = true;
      return callback(error);
    }
  };

  onData = function(data) {
    console.log("onData");
    tasksLaunched++;
    wait.launchFiber(processChunk,data,resultReady);
  };

  fs.createReadStream(filename)
    .on('data', onData)
    .on('end', function() {
        console.log("end");
    })
    .on('error', function(error) {
        console.log("error", error);
        if (!callbackDone) {
            callbackDone = true;
            return callback(error);
          }
    });
};

function mainFiber() {
  console.log("Calling processFile");
  var data = wait.for(processFile,'/bin/bash');
  console.log(data.length,"results");
  console.log("processFile returned");
};

//MAIN
wait.launchFiber(mainFiber);
console.log("back in main");

---

减少睡眠时间，并为其他块设置一些优先级或计时器。 这样，在一定的时间限制后，根据优先级显示块。

---

这就是如何以所需的方式获得输出。

似乎没有人知道如何满足您的要求

在这种情况下，您可以以某种传统的异步方式处理流，将屈服函数应用于结果

下面是一些如何做到这一点的例子

---

使用

原始主体收集所有流数据
一种解决方案是在处理任何流数据之前收集所有流数据。这可以通过以下方式轻松完成：

使用此示例，您将：

等待所有块到达
在
光纤中启动数据流处理

从
processData
返回到主线程
流数据将在将来的某个时候进行处理
如果需要，您可以添加
尝试。。。捕获
或任何其他异常处理，以防止
处理数据
破坏您的应用程序


使用智能作业队列处理系列中的所有区块
但是，如果您真的想在数据到达时处理所有数据块，您可以使用一些智能控制流模块。以下是使用from的示例：

使用此示例，您将：

开始收听
流
，
将每个新块推送到处理队列

当
流关闭时，从
processData
返回到主线程，而不是等待处理数据块

所有数据块都将在某个时间点以严格的顺序进行处理

我知道这不是你所要求的，但我希望它能帮助你。
只需删除
sleepForMs（500）
Sleep是否有其他可能产生的光纤功能的示例。问题是
onException
和
onData
在单独的
光纤中执行（请参见
返回光纤（运行））.run（）
阻塞
if（Fiber.current）
函数中的条件（catchError
函数），因为所有
.on
回调出现在当前
光纤
之外。是的，如何使它们在一根光纤内工作？不要使用光纤？v0.11中的节点有自己的
yield
函数（实际上JS有）：检查
node--harmony\u generators
…我认为问题的关键是使用一些yieldind函数顺序处理到达的数据块。考虑到“期望的输出”，他似乎希望在processFile返回之前完成这两个任务。这只是一个例子。想象一下，任何其他光纤功能都可以产生。我希望能够在回调中为每个数据块调用它，而不必担心其他数据块在此期间正在做什么。这样，事情就会像你所期望的那样阻止调用。我改变了答案，为每个块启动一个光纤。如果
sleepForMs
是一个光纤产生函数而不是基于回调的函数，它会工作吗？睡眠时间只是一个可以产生响应的函数的例子。
var rawBody = require('raw-body');

function processData(data) {
  console.log("before sleep");
  sleepForMs(500);
  console.log("after sleep");
}

function processFile(callback) {
  var stream = fs.createReadStream('fiber.js');
  rawBody(stream, function(err, data) {
    if (err) return callback(err);
    Fiber(processData).run(data); // process your data
    callback();
  });
}

function processChunk(data, next) {
  return function() {
    console.log("before sleep");
    sleepForMs(500);
    console.log("after sleep");
    next();
  }
}

function processFile(callback) {
  var q = async.queue(function(data, next) {
    Fiber(processChunk(data, next)).run();
  }, 1);
  fs.createReadStream('fiber.js').on('data', function(data) {
    q.push(data);
  }).on('error', function(err) {
    callback(err);
  }).on('end', function() {
    callback(); // not waiting to queue to drain
  })
}