Detailed explanation of HTTP module and event module in Node.js

http server for Node.js

Node.js allows us to create servers and clients by using the low-level API of the HTTP module. When we first started learning node, we would all encounter the following code:

var http = require('http');
http.createServer(function (req,res) {
    res.end('Hello World\n');
}).listen(3000,"127.0.0.1");
console.log("Server funning at http://127.0.0.1:3000");

This code includes information about the http module, which means:

1. From the core of `Node.js` Requests the HTTP module and assigns it to a variable for use in future scripts.
The script then has access to methods for using `HTTP` via `Node.js`.

2. Create a new web server object using `createServer`

3. The script passes an anonymous function to the server, telling the web server object what to happen whenever it receives a request. What

4. Line 4 of the script defines the port and host of the web server, which means the server can be accessed using `http://127.0.0.1:3000`
Http header

For every HTTP request and response, an HTTP header is sent. The HTTP header sends additional information, including the content type, the date the server sent the response, and the HTTP status code

http The header contains a lot of information. The following is the http header information contained in my Baidu homepage:

Since I have added more websites to my Baidu homepage, the data here It may be different from readers. From this we can see that Baidu's web server is BWS/1.1

The following is the http header information of the above code:

Node.js Redirection in node

In node, we can easily create a simple server to redirect visitors to another Web page. The guidelines are as follows:

1. To the customer Send a 301 response code to tell the client that the resource has been moved to another location;

2. Send a location header to tell the client where to redirect.

The relevant code is as follows:

var http = require('http');
http.createServer(function (req,res) {
    res.writeHead(301,{
        'Location':'Http://example-2.com/web'
    });
    res.end();
}).listen(3000,'127.0.0.1');
console.log("Server funning at http://127.0.0.1:3000");

Open the browser to access the http://127.0.0.1:3000 page and you will be redirected.

Response to different requests

Node.js can not only create a single response, but for multiple types of requests, we need to add some routes to the application. Node makes this straightforward by using the URL module. The URL module allows us to read a URL, parse it and then do something with the output.

var url = require('url');
var requestURL = "http://example.com:1234/path?query=string#hash"

Now, we can analyze the requested URL and intercept the content from it. For example, to get the host name, we can enter:

url.parse(requestURL).hostname

At this time, it will return "example.com"

To get the port number, you can enter:

url.parse(requestURL).port

It will return "1234"

Event module

Node.js is considered is the best way to achieve concurrency. The Events module is the core of Node.js and is used by many other modules to architect functionality around events. Since Node.js runs in a single thread, any synchronization code is blocking. So, there are some simple rules to consider when writing Node.js code:

1. Don’t block - `Node.js` is single-threaded, if the code blocks everything else stops

2. Quick return - the operation should return quickly. If it cannot be returned quickly, it should be moved to another process

The Events module allows developers to set listeners and handlers for events. In client js, we can set a listener for the click event, and then perform something when the event occurs:

var tar = document.getElementById("target");
tar.addEventListener("click", function () {
   alert("click event fired,target was clicked"); 
},false);

Of course, this is an example without considering IE compatibility, Node.js is the focus Events are more commonly network events, including:

1. Response from web server

2. Reading data from file

3. Returning data from database
Using the Events module we first To create a new EventEmitter instance:

var EventEmitter= require('events').EventEmitter;
var test = new EventEmitter();

Once you have the above in your code, it is time to add events and listeners, we can send events as follows, for example:

test.emit('msg','the message send by node');

First The first parameter is a string describing the event, so that it can be used for matching the listener

In order to receive the message, a listener must be added, and the listener will handle the event when it is triggered, for example:

test.on('message',function(data){
    console.log(data);
});

Events module implements basic event listening mode methods such as addListener/on, once, removeListener, removeAllListeners, and emit. It is not the same as the events on the front-end DOM tree, because it does not have event behaviors belonging to the DOM such as bubbling and layer-by-layer capture, and there are no methods to handle event delivery such as preventDefault(), stopPropagation(), stopImmediatePropagation(), etc.

1. Class: events.EventEmitter: Obtain the EventEmitter class through require('events').EventEmitter.

2.emitter.on(event, listener): Add a listener to the end of the listener array for a specific event. Return emitter to facilitate chain calls, the same below.

3.emitter.removeListener(event, listener)Removes a listener from the listener array of an event

4.emitter.listeners(event)Returns the listener array of the specified event

More For details, see: Node.js API documentation

The following code shows a confidential message that can self-destruct in 5 seconds:

var EventEmitter = require('events').EventEmitter;
var secretMessage = new EventEmitter();
secretMessage.on('message', function (data) {
   console.log(data); 
});
secretMessage.on('self destruct', function () {
    console.log('the msg is destroyed!');
});
secretMessage.emit('message','this is a secret message.It will self deatruct in 5s');
setTimeout(function () {
   secretMessage.emit('self destruct');
},5000);

在这段脚本中，发送了两个事件，有两个侦听器。当脚本运行时，消息事件就发生，并由“message”处理器处理

在Node.js中到处都用EventEmitter，所以掌握它是很重要的。Node.js通过I/O操作获得的数据并广泛使用Events模块来支持异步编程

常见问题解答：

问：对于一个事件是否有最大侦听器数量的限制？
答：默认情况下，如果事件有操作10个侦听器，它会发出警告。不过，可以使用emitter.setMaxListener(n)来更改这个数量

问：是否可以侦听所有发送出来的事件？
答：不能。我们需要给每个想要响应的事件创建侦听器

更多Detailed explanation of HTTP module and event module in Node.js相关文章请关注PHP中文网！