About the use of Node.js time loop

Node.js has better performance, so it is often seen in use, so this article will explain it in detail.

Node.js is a single-process, single-threaded application, but supports concurrency through events and callbacks, so its performance is very high.

Every API in Node.js is asynchronous and runs as a separate thread, uses asynchronous function calls, and handles concurrency.

Node.js Basically all event mechanisms are implemented using the observer pattern in the design pattern.

Node.js single thread is similar to entering a while(true) event loop until no event observer exits. Each asynchronous event generates an event observer. If an event occurs, the callback function is called.

Event-driven program

Node.js uses the event-driven model. When the web server receives a request, it closes it and processes it, and then serves the next web request.

When the request is completed, it is put back into the processing queue, and when the beginning of the queue is reached, the result is returned to the user.

This model is very efficient and scalable because the webserver always accepts requests without waiting for any read or write operations. (This is also called non-blocking IO or event-driven IO)

In the event-driven model, a main loop is generated to listen for events, and a callback function is triggered when an event is detected.

The entire event-driven process is implemented in this way, very simple. Somewhat similar to the observer pattern, the event is equivalent to a subject (Subject), and all handler functions registered to this event are equivalent to observers (Observer).

Node.js has multiple built-in events. We can bind and listen to events by introducing the events module and instantiating the EventEmitter class, as shown in the following example:

// 引入 events 模块var events = require('events');// 创建 eventEmitter 对象var eventEmitter = new events.EventEmitter();
以下程序绑定事件处理程序：
// 绑定事件及事件的处理程序eventEmitter.on('eventName', eventHandler);
我们可以通过程序触发事件：
// 触发事件eventEmitter.emit('eventName');

Example

Create the main.js file, the code is as follows:

// 引入 events 模块var events = require('events');// 创建 eventEmitter 对象var eventEmitter = new events.EventEmitter();// 创建事件处理程序var connectHandler = function connected() {
   console.log('连接成功。');
  
   // 触发 data_received 事件 
   eventEmitter.emit('data_received');}// 绑定 connection 事件处理程序eventEmitter.on('connection', connectHandler);
 // 使用匿名函数绑定 data_received 事件eventEmitter.on('data_received', function(){
   console.log('数据接收成功。');});// 触发 connection 事件 eventEmitter.emit('connection');console.log("程序执行完毕。");

Next let us execute the above code:

$ node main.js connection is successful. Data received successfully. The program execution is completed.

How does Node application work?

In Node applications, functions that perform asynchronous operations take the callback function as the last parameter, and the callback function receives the error object as the first parameter.

Next, let us re-look at the previous example and create an input.txt. The file content is as follows:

Official website address of the rookie tutorial: www.runoob.com

Create the main.js file with the following code:

var fs = require("fs");fs.readFile('input.txt', function (err, data) {
   if (err){
      console.log(err.stack);
      return;
   }
   console.log(data.toString());});console.log("程序执行完毕");

The above introduces the use of Node.js in detail. If you want to know more related knowledge, please pay attention to the php Chinese website.

Related recommendations:

Detailed explanation of the principle of port reuse in Node.Js

What are the registration email activations for Node.js Method

How Node.Js implements Bitcoin address

The above is the detailed content of About the use of Node.js time loop. For more information, please follow other related articles on the PHP Chinese website!