Using factory methods as alternative to passing anonymous functions

I was watching a video on node.js and I saw the speaker say, he prefers to do this instead of using anonymous call backs:

var server = Server.createServer(server.createReq(req,res));

I think its nice too that a named function with parameters can be passed instead of an anonymous function with closure.

Quest开发者_开发技巧ion 1: However the implementation of the createReq probably returns an anonymous function, wouldn't it?

How is this better? I can see it being better because unlike the closure at the createServer level, a closure at the createReq level is more contained - it would not store reference to other unnecessary variables (non req,res).

And as the speaker said, I guess this would help visualize realtionships better between the different parts of the code.

Question 2: Are there any other benefits?

---

A reason why you might want to call a function that returns a function may be that you are starting multiple servers within the same process, and you want them to share the same request handler.

Another thing to keep in mind is that each anonymous function must be allocated on the heap, and thus incurs some garbage collection overhead. By using a named function instead of an anonymous function, you can sometimes reduce this cost.

For example, maybe something like this untested and incomplete example:

var server = Server.createServer(handleRequest);

function handleRequest(req, res) {
    new Client(req, res);
}

function Client(req, res) {
    this.req = req;
    this.res = res;

    this.body = "";
    req.on("data", function (chunk) {
        self.onData(chunk);
    });
}
Client.prototype.onData = function (chunk) {
    this.body += chunk.toString();
};

This example uses a small anonymous function to bind the data event callbacks back to the specific instance of Client, but all other functions are named.