Node.js nodejs读取文件并发出http请求

有一个Nodejs脚本可以逐个读取一组文件。对于每个文件，逐行读取文档，在读取一行之后，它将要求http post将该行发送到远程服务器。然后读下一行。问题是剧本会漏掉一些台词

多谢各位

似乎

lr.pause（）只需隐藏
行
事件，而不是暂停读取文件过程

var fs = require('fs');
var http = require('http');
var JSON = require('JSON');
var S = require('string');
var uuid = require('node-uuid');
var readline = require('readline');
var httpsync = require('httpsync');
var LineByLineReader = require('line-by-line');
var sleep = require('sleep');

function postES(_path,data,id,lr){
  var post_data = JSON.stringify(data);
  var post_options = {
      host: _host,
      port: _port,
      path: _path,
      method: 'POST',
      headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
          'Content-Length': post_data.length
      }
  };
  var post_req = http.request(post_options, function(res) {
      res.setEncoding('utf8');
      res.on('data', function(data) {
        console.log(data);
      });
      res.on('end', function() {
        console.log("end");
        // resume read line
        lr.resume(); 
      });
  });
  post_req.on('error', function(data) {
    console.log("error,post."+data+post_data);
    // resume read line
    lr.resume();
  }); 
  post_req.write(post_data);
  post_req.end();
}


function readlineFunSession(line,id,lr) { 
    var _data={};
    // compose _data object
    postES('/cs/session/'+_data["sessionid"],_data,id,lr);
}

function readfileFun(files,start,end,id,readlineFun) {
  if(start<end && start<files.length){
    var lr = new LineByLineReader(files[start],{encoding:'utf8',skipEmptyLines:true});
    lr.on('error', function (e) {
      console.log('error,LineByLineReader.'+e.toString());
    });
    lr.on('line', function (line) {
      // pause read line
      lr.pause();
      try{
        readlineFun(line,id,lr);
      }catch(e){
        console.log('error,line.'+e.toString());
      }
    });
    lr.on('end', function () {
      readfileFun(files,++start,end,id,readlineFun);
    });
  }
}

// var files is an arry of files
// this function try to go throgh file[0],file[1],file[2],......,file[10],
readfileFun(files,0,10,"ID-1",readlineFunSession);

var fs=require（'fs'）；
var http=require（'http'）；
var JSON=require（'JSON'）；
var S=require（'string'）；
var uuid=require（'node-uuid'）；
var readline=require（'readline'）；
var httpsync=require（'httpsync'）；
var LineByLineReader=require（‘逐行’）；
var sleep=require（‘sleep’）；
函数postES（_路径、数据、id、lr）{
var post_data=JSON.stringify（数据）；
var post_选项={
主持人:"主持人,，
端口：_端口，
路径：_路径，
方法：“POST”，
标题：{
“内容类型”：“应用程序/x-www-form-urlencoded”，
“内容长度”：post_data.Length
}
};
var post_req=http.request（post_选项，函数（res）{
res.setEncoding（'utf8'）；
res.on（'数据'），函数（数据）{
控制台日志（数据）；
});
res.on（'end'，function（）{
控制台日志（“结束”）；
//恢复读取行
lr.resume（）；
});
});
post_请求on（'error'，函数（数据）{
console.log（“错误，post.”+数据+post_数据）；
//恢复读取行
lr.resume（）；
}); 
post_请求写入（post_数据）；
post_请求结束（）；
}
函数readlineFunSession（行，id，lr）{
var_data={}；
//组合数据对象
postES（'/cs/session/'+_-data[“sessionid”]，_-data，id，lr）；
}
函数readfileFun（文件、开始、结束、id、readlineFun）{
如果（start执行一系列操作，其中下一个操作应该在nodejs中的当前完成之后运行，但由于其异步范例，这有点困难，那么您可以使用sync-maker npm，比如fiber或瀑布

但另一个简单（而且愚蠢）的方法是创建虚拟工作者管理器，让你的NodeJ无限运行，同时每（时间间隔），检查当前进度是否完成，如果完成了，运行下一个操作

顺便说一句，虽然您不能请求成为同步，但您可以同步读取文件，所以在您的情况下，我认为您应该读取所有文件中的所有行，以成为一个大的行数组

var jswget = require("jswget");
var arrayoflines = ["line1", "line2", "line3"];
var counter = 0;
var inProgress = false;
var request = function(){
    if (arrayoflines.length == 0) {
        // no more line, should exit
        process.exit();
    }        
    if (inProgress) {
       // if previous work is not completed then skip.
       return;
    }
    // get first line, and remove it from array index
    var current_line = arrayoflines.shift();
    inProgress = true;
    jswget({
       url: "http://someurl:3000/somepath?q1=" + current_line,
       method: 'POST',
       formdata: some_postdata,
       headers: {
         'Content-Type': 'application/x-www-form-urlencoded',
         'Content-Length': post_data.length
       },
       onsuccess: function(responsetext, req, res){
          // success requesting, should do next line
       },
       onerror: function(err, req){
          // oops, error occurred, but we will do next line nevertheless
       },
       onend: function(){
          // success or not, the request is end, so we should prepare for next request
          counter+=1;
          inProgress = false;
       }
    })
}
setInterval(function(){
   request();
}, 100)

这可能会帮助你

使用节点0.12，现在可以同步执行此操作：

  var fs = require('fs');
  var path = require('path');

  // Buffer mydata
  var BUFFER = bufferFile('../public/mydata.txt');

  function bufferFile(relPath) {
    return fs.readFileSync(path.join(__dirname, relPath)); // zzzz....
  }

fs
是文件系统。如果需要，将返回缓冲区或字符串

fs
正确地假设相对路径是一个安全问题。
path
是一个解决方法

要作为字符串加载，请指定编码：

return fs.readFileSync(path,{ encoding: 'utf8' });