ciclo di eventi Node.js

Node.js è un applicazioni a thread singolo singolo processo, ma supporta simultaneo tramite eventi e callback, quindi le prestazioni è molto alta.

Ogni API Node.js è asincrono e viene eseguito come un thread separato, utilizzando chiamate di funzione asincrone, e la concorrenza.

Node.js sostanzialmente tutto il meccanismo di evento viene implementato utilizzando la modalità osservatore modalità di progettazione.

Node.js è simile a entrare in un unico filo while (true) ciclo di eventi fino a quando non vi è alcun osservatore evento di uscita, ogni evento asincrono genera un osservatore evento, se si verifica un evento che viene chiamato la funzione di callback.

---

programmazione event-driven

Node.js utilizzando il modello event-driven, quando il server Web riceve la richiesta, e quindi rimandare per l'elaborazione e quindi alla successiva richiesta di servizio web.

Quando la richiesta è completata, viene restituito alla coda di elaborazione, la coda quando raggiunge l'inizio, il risultato viene restituito all'utente.

Questo modello è molto efficiente scalabilità è molto forte, perché il server web ha ricevuto richieste senza attendere alcuna operazione di lettura o scrittura. (Questo è anche conosciuto come IO non bloccante IO o event-driven)

Nel modello event-driven, genera un ciclo principale per ascoltare gli eventi per attivare una funzione di callback quando viene rilevato un evento.

L'intero processo è così event-driven per raggiungere, è molto semplice. Un po 'simile al modello dell'osservatore, l'evento è equivalente a un tema (Oggetto), mentre tutti gestione registrato a questo evento corrisponde all'osservatore (Observer).

Node.js ha molteplici eventi built-in, siamo in grado attraverso l'introduzione del modulo di eventi e di legare e ascolto per gli eventi di un'istanza di classe EventEmitter seguenti esempi:

// 引入 events 模块
var events = require('events');
// 创建 eventEmitter 对象
var eventEmitter = new events.EventEmitter();

Il gestore di eventi legame seguente procedura:

// 绑定事件及事件的处理程序
eventEmitter.on('eventName', eventHandler);

Siamo in grado di programmare l'evento scatenante:

// 触发事件
eventEmitter.emit('eventName');

Esempi

Creare file di main.js, il codice è il seguente:

// 引入 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("程序执行完毕。");

Cerchiamo di eseguire il codice di cui sopra:

$ node main.js
连接成功。
数据接收成功。
程序执行完毕。

---

Come lavoro di applicazione del nodo?

In Node funzione applicazione esegue una funzione di un'operazione callback asincrona come ultima funzione parametro callback riceve l'oggetto errore come il primo parametro.

Cerchiamo di ri-guardare l'esempio precedente, creare un input.txt, documento redatto come segue:

本教程官网地址：www.w3big.com

Creare file di main.js, come segue:

var fs = require("fs");

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

Programma sopra fs.readFile () è una funzione asincrona viene utilizzata per leggere il file. Se si verifica un errore nel processo di lettura del file, l'errore err oggetti emette un messaggio di errore.

Se non ci sono errori, readFile saltare oggetto di output Err, il contenuto del file viene trasmesso attraverso la funzione di callback.

Eseguire il codice di cui sopra, i risultati di esecuzione sono i seguenti:

程序执行完毕
本教程官网地址：www.w3big.com

Successivo cancelliamo file di input.txt risultati di esecuzione sono i seguenti:

程序执行完毕
Error: ENOENT, open 'input.txt'

Input.txt perché il file non esiste, per cui l'uscita del messaggio di errore.