Question

我来自龙卷风，你有一个requestHandler类，你匹配查询以将其定位到正确的requestHandler。

你怎么做node.js？像那样????

http=require ('http');
url=require('url')


function case1(request,response){ ... }

function case2(request,response){ ... }

http.createServer(function(request, response) {
     var q=url.parse(request.url, true).query
     switch(true){
       case /friend/.test(q):
           case1(request,response);
           return;
       case /foes/.test(q):
           case2(request,response);
           return;
     }
}).listen(9999)

Answer 1

使用Node.js'http.Server，您可以自行建立任何路由。

而且，你接近这一点。但是，您需要根据已解析的网址pathname而不是query进行测试。

var pathname = url.parse(request.url, true).pathname;

switch (true) {
    case /\/friend/.test(pathname):
        case1(request, response);
        break;

    case /\/foes/.test(pathname):
        case1(request, response);
        break;
}

您可能还希望包含对request.method的测试。

case request.method === 'GET' && /\/friend/.test(pathname):

或者，正如soulcheck提到的那样，numerous libraries/framework available有已建立的路由API，包括express和restify。

var app = express();

app.get('/friend', case1);
app.get('/foes', case2);

Answer 2

这是一个替代解决方案：您可以使用函数组合将多个处理程序组合成一个处理程序。如果req.url没有匹配，则每个处理程序应该将执行产生到下一个处理程序。可以进一步扩展wrapHandler以考虑HTTP方法。

var http = require('http');

var handler1 = function(req, res) {
    res.writeHead(200, { 'Content-Type': 'text/html' });
    res.write('/');
    res.end();  
}

var handler2 = function(req, res) {
    res.writeHead(200, { 'Content-Type': 'text/html' });
    res.write('/Hello');
    res.end();  
}

var middleware = compose([wrapHandler('/', handler1),
                         wrapHandler('/hello', handler2)]);

http.createServer(middleware).listen(3000);

function wrapHandler(path, cb) {
    return function (req, res, next) {
        if (req.url === path) {
            cb(req, res);
        } else {
            next();
        }
    };
}

function notFoundHandler(req, res) {
    res.writeHead(404, { 'Content-Type': 'text/html' });
    res.write('No Path found');
    res.end();    
};

// adapted from koa-compose
function compose(middleware) {
    return function (req, res){
        let next = function () {
            notFoundHandler.call(this, req, res);
        };

        let i = middleware.length;
        while (i--) {
            let thisMiddleware = middleware[i];
            let nextMiddleware = next;
            next = function () { 
                thisMiddleware.call(this, req, res, nextMiddleware);
            }
        }
        return next();
    }
}

你如何在node.js中使用多个请求处理程序？

2 个答案: