How to implement routing function in nodejs

This article mainly introduces the implementation of routing function in nodejs. As the name suggests, routing means that we have different processing methods for different URLs. This article will teach you how to implement routing function in node.js. Friends who need it can For reference,

I am new to Node and found a situation that is completely different from my previous views - what is JavaScript used for in your eyes? Special effects? or just interaction with the client? It can be said that JavaScript first ran in the browser. However, if you think about it this way, the browser just provides you with a context (context), which defines what can be done using JavaScript. It can be thought of as a similar enterprise. It defines what you can do here, but doesn't say much about what the JavaScript language itself can do. In fact, as a complete language, JavaScript can be used in different contexts and reflect different capabilities. The Nodejs mentioned here actually provides a context, a running environment, which allows JavaScript code to be run on the backend (out of the browser environment).

The core of routing selection is routing. As the name implies, routing means that we have different processing methods for different URLs, such as processing the business logic of /start and processing the business of /upload module; the logic is inconsistent . In a realistic implementation, the routing process will "end" in the routing module, and the routing module is not the module that actually "takes action" on the request, otherwise it will not be available when our application becomes more complex. Nice extension.

Here we first create a module called requestHandlers, and add a placeholder function to each request handler:

function start(){   
    console.log("Request handler 'start' was called.");   
       
    function sleep(milliSeconds){   
        var startTime=new Date().getTime();   
        while(new Date().getTime()<startTime+milliSeconds);   
    }   
    sleep(10000);   
    return "Hello Start";   
}   
function upload(){   
    console.log("Request handler &#39;upload&#39; was called.");   
    return "Hello Upload";   
}   
  
exports.start=start;   
exports.upload=upload;

So that we can connect the request handler and the routing module, Let the route have a path to follow. After that, we determined to pass a series of request handlers through an object, and we need to use a loose coupling method to inject this object into the router() function. The main file index.js:

var server=require("./server");   
var router=require("./router");   
var requestHandlers=require("./requestHandlers");   
  
var handle={};   
handle["/"]=requestHandlers.start;   
handle["/start"]=requestHandlers.start;   
handle["/upload"]=requestHandlers.upload;   
  
server.start(router.route,handle);

is as shown above, Mapping different URLs to the same request handler is easy: just add a property with the key "/" to the object corresponding to requestHandlers.start. In this way, we can simply configure that requests for /start and / are handled by the start handler. After completing the definition of the object, we pass it to the server as an additional parameter, see server.js:

var http=require("http");   
var url=require("url");   
  
function start(route,handle){   
    function onRequest(request,response){   
        var pathname=url.parse(request.url).pathname;   
        console.log("Request for "+pathname+" received.");   
           
        route(handle,pathname);   
           
        response.writeHead(200,{"Content-Type":"text/plain"});   
        var content=route(handle,pathname);   
        response.write(content);   
        response.end();   
    }   
    http.createServer(onRequest).listen(8888);   
    console.log("Server has started.");   
}    
exports.start=start;

In this way, the handle parameter is added to the start() function, and the handle object is used as the first A parameter is passed to the route() callback function. Route.js is defined below:

function route(handle,pathname){  
    console.log("About to route a request for "+ pathname);   
    if(typeof handle[pathname]==='function‘){   
        return handle[pathname]();   
    }else{   
        console.log("No request handler found for "+pathname);   
        return "404 Not Found";   
    }   
}   
exports.route=route;

Through the above code, we first check whether the request handler corresponding to the given path exists, and if it exists, call the corresponding one directly. The function. We can get the request processing function from the passed object in the same way as getting elements from the associative array, that is, handle[pathname](); such an expression gives people the feeling of saying "Hi, please Come and help me handle this path." The running effect of the program is as follows:

The above is the entire content of this article. I hope it will be helpful to everyone's study. For more related content, please Follow PHP Chinese website!

Related recommendations:

How to quickly use node.js for web development

Analysis of the Http module of Nodejs

How to solve nodejs path problem

The above is the detailed content of How to implement routing function in nodejs. For more information, please follow other related articles on the PHP Chinese website!