在node.js中，对服务器'request event'的回调是如何工作的？

我试图使用带有闭包的咖喱fn作为对服务器的回调

它在客户端第一次发出请求（发送并显示html）时起作用，但在第二次页面为空白时起作用。节点在调用cb一次后是否会擦除闭包

// server.js
var pype = function(self, arr, errorHandler, cb) {
  var i = 0,
  req,
  res,
  run = function() {
    arr[i].call(self, req, res, next);
  },
  next = function(err) {
    if (err && errorHandler) {
      return errorHandler.call(self, err, req, res);
    }
    i++
    if (i < arr.length) {
      return run();
    } else if (cb) {
      return cb.call(self, req, res);
    }
  }

  return function(request, response) {
    req = request;
    res = response;
    run();
  }
};

var http = require("http”);
var server = http.createServer();
var errorhandler = function(err, req, res) {
  res.end(err);
},
var finalHandler = function(req, res) {
  res.setHeader("Content-Type", "text/html");
  res.end(req.html);
};
var requestHandler = pype(null, [pens, gits, concat, index, sort, html, finalHandler], errorhandler);

// this works only once
server.on('request', requestHandler);

// this works for multiple calls
server.on('request', function(req, res){
  var requestHandler = pype(null, [pens, gits, concat, index, sort, html, finalHandler], errorhandler);
  requestHandler(req, res);
});

//server.js
var pype=函数（self、arr、errorHandler、cb）{
var i=0，
请求，
物件，
运行=函数（）{
arr[i]。调用（self、req、res、next）；
},
next=函数（err）{
if（err&&errorHandler）{
返回errorHandler.call（self、err、req、res）；
}
我++
如果（i

---

谢谢！

节点不会删除任何闭包

在我看来，当您处理完一个请求或启动一个新请求时，您从未将

I

重置回

0

。因为闭包无限期地保留其所有状态，所以当第二个请求进入时，

I

将指向数组的结尾之外，您将永远不会调用数组中的任何函数

您可以在处理请求时或在新请求开始时将

i

重置回

0

对此进行更改：

  return function(request, response) {
    req = request;
    res = response;
    run();
  }

为此：

  return function(request, response) {
    req = request;
    res = response;
    i = 0;
    run();
  }

要解决该特定问题，您还存在其他问题（请参见下文）

---

不过，这个结构似乎还有其他问题。因为您只创建一个闭包，然后对所有请求重用它，所以每当您的第一个请求异步处理某个内容，而第二个请求在此期间到达时，您将删除第一个请求的闭包变量，这两个变量将发生冲突。此方案对于任何一台想要一次处理多个请求的服务器来说，单一永久性关闭的设计都是站不住脚的

您的第二次尝试效果良好，这是一种更好的方法，因为您为每个请求创建了一个新的独立闭包，当多个请求同时运行时，该闭包不会出现竞争条件问题

---

我必须说，我真的不认为这里需要咖喱风格。你不想创建一个永久性的闭包，它会无限期地持续下去（每个请求都需要一个新的闭包）。而且，它会让你的代码更难理解和遵循

---

如果没有咖喱，对我来说似乎简单得多：

var http = require("http");
var server = http.createServer();

function handleRequest(ctx, req, res, handlers) {
    return new Promise(function(resolve, reject) {
        var i = 0;

        function next(err) {
            if (err) {
                reject({err, req, res, ctx});
            } else {
                run();
            }
        }

        function run() {
            if (i < handlers.length) {
                handlers[i++].call(ctx, req, res, next);
            } else {
                resolve({req, res, ctx});
            }
        }
        run();
    }
}

function errorhandler(info) {
  info.res.end(info.err);
}

function finalHandler(info) {
  info.res.setHeader("Content-Type", "text/html");
  info.res.end(req.html);
}


server.on('request', function(req, res) {
    handleRequest(null, req, res, [pens, gits, concat, index, sort, html]).then(finalHandler, errorHandler);
});

var http=require（“http”）；
var server=http.createServer（）；
函数handleRequest（ctx、req、res、处理程序）{
返回新承诺（功能（解决、拒绝）{
var i=0；
函数下一步（err）{
如果（错误）{
拒绝（{err，req，res，ctx}）；
}否则{
run（）；
}
}
函数运行（）{
if（i<0.length）{
处理程序[i++].call（ctx、req、res、next）；
}否则{
解析（{req，res，ctx}）；
}
}
run（）；
}
}
函数errorhandler（信息）{
info.res.end（info.err）；
}
函数finalHandler（信息）{
info.res.setHeader（“内容类型”、“文本/html”）；
info.res.end（req.html）；
}
服务器打开（'request'，函数（req，res）{
handleRequest（null、req、res、[pens、gits、concat、index、sort、html]），然后（finalHandler、errorHandler）；
});

节点不会删除任何闭包

在我看来，当您处理完一个请求或启动一个新请求时，您从未将

I

重置回

0

。因为闭包无限期地保留其所有状态，所以当第二个请求进入时，

I

将指向数组的结尾之外，您将永远不会调用数组中的任何函数

您可以在处理请求时或在新请求开始时将

i

重置回

0

对此进行更改：

  return function(request, response) {
    req = request;
    res = response;
    run();
  }

为此：

  return function(request, response) {
    req = request;
    res = response;
    i = 0;
    run();
  }

要解决该特定问题，您还存在其他问题（请参见下文）

---

不过，这个结构似乎还有其他问题。因为您只创建一个闭包，然后对所有请求重用它，所以每当您的第一个请求异步处理某个内容，而第二个请求在此期间到达时，您将删除第一个请求的闭包变量，这两个变量将发生冲突。此方案对于任何一台想要一次处理多个请求的服务器来说，单一永久性关闭的设计都是站不住脚的

您的第二次尝试效果良好，这是一种更好的方法，因为您为每个请求创建了一个新的独立闭包，当多个请求同时运行时，该闭包不会出现竞争条件问题

---

我必须说，我真的不认为这里需要咖喱风格。你不想创建一个永久性的闭包，它会无限期地持续下去（每个请求都需要一个新的闭包）。而且，它会让你的代码更难理解和遵循

---

如果没有咖喱，对我来说似乎简单得多：

var http = require("http");
var server = http.createServer();

function handleRequest(ctx, req, res, handlers) {
    return new Promise(function(resolve, reject) {
        var i = 0;

        function next(err) {
            if (err) {
                reject({err, req, res, ctx});
            } else {
                run();
            }
        }

        function run() {
            if (i < handlers.length) {
                handlers[i++].call(ctx, req, res, next);
            } else {
                resolve({req, res, ctx});
            }
        }
        run();
    }
}

function errorhandler(info) {
  info.res.end(info.err);
}

function finalHandler(info) {
  info.res.setHeader("Content-Type", "text/html");
  info.res.end(req.html);
}


server.on('request', function(req, res) {
    handleRequest(null, req, res, [pens, gits, concat, index, sort, html]).then(finalHandler, errorHandler);
});

var http=require（“http”）；
var server=http.createServer（）；
函数handleRequest（ctx、req、res、处理程序）{
返回新承诺（功能（解决、拒绝）{
var i=0；
函数下一步（err）{
如果（错误）{
拒绝(