Quali sono i casi d’uso corretti per process.nextTick in Node.js?

Ho visto process.nextTick utilizzato in alcuni punti e non riesco a capire a cosa serve.

  • https://github.com/andrewvc/node-paperboy/blob/master/lib/paperboy.js#L24
  • https://github.com/substack/node-browserify/blob/master/index.js#L95

Quali sono i casi di utilizzo principale / principale di process.nextTick in Node.js? In pratica, i documenti dicono che è un modo più ottimizzato di fare setTimeout , ma questo non aiuta molto.

Ho usato molto ActionScript, quindi l’idea di “aspettare fino al prossimo fotogramma” per eseguire il codice ha senso a un certo livello – se stai eseguendo un’animazione puoi farlo aggiornare ogni fotogramma anziché ogni millisecondo, ad esempio. Ha anche senso quando si desidera coordinare l’impostazione di un gruppo di variabili: si modificano le variabili nel fotogramma 1 e si applicano le modifiche nel fotogramma 2. Flex ha implementato qualcosa di simile nel loro ciclo di vita dei componenti.

La mia domanda è, cosa dovrei usare per questo in JavaScript lato server? Non vedo nessun posto a portata di mano in cui avresti bisogno di questo tipo di controllo di stream / prestazioni ottimizzato. Sto solo cercando un punto nella giusta direzione.

process.nextTick mette una richiamata in coda. Ogni callback in questa coda verrà eseguito all’inizio del prossimo tick del ciclo degli eventi. Fondamentalmente è usato come un modo per cancellare lo stack delle chiamate. Quando la documentazione dice che è come setTimeout , vuol dire che è come usare setTimeout(function() { ... }, 1) nel browser. Ha gli stessi casi d’uso.

Un caso d’uso di esempio sarebbe, si crea un costruttore per un object che ha bisogno di eventi ad esso associati. Tuttavia, non è ansible iniziare subito ad emettere eventi, perché il codice che lo ha istanziato non ha ancora avuto il tempo di collegarsi agli eventi. La chiamata del costruttore è sopra di loro nello stack delle chiamate e, se continui a fare cose sincrone, rimarrà tale. In questo caso, è ansible utilizzare un process.nextTick prima di procedere a ciò che si stava per fare. Garantisce che la persona che utilizza il costruttore avrà tempo sufficiente per associare gli eventi.

Esempio:

 var MyConstructor = function() { ... process.nextTick(function() { self._continue(); }); }; MyConstructor.prototype.__proto__ = EventEmitter.prototype; MyConstructor.prototype._continue = function() { // without the process.nextTick // these events would be emitted immediately // with no listeners. they would be lost. this.emit('data', 'hello'); this.emit('data', 'world'); this.emit('end'); }; 

Esempio di middleware utilizzando questo costruttore

 function(req, res, next) { var c = new MyConstructor(...); c.on('data', function(data) { console.log(data); }); c.on('end', next); } 

Mette semplicemente la tua funzione alla fine del ciclo degli eventi. Di solito quando si eseguono elaborazioni sincrone pesanti, è meglio utilizzare process.nextTick per ogni blocco di codice, per assicurarsi che il processo non blocchi altri eventi. Quando lo fai, dopo aver raggiunto proess.nextTick e la funzione termina, elabora altri eventi come le richieste http, quindi raggiunge process.nextTick callback e lo esegue.

A parte questo se puoi usarlo per eseguire una funzione in modo ricorsivo, senza che lo stack delle chiamate sia in overflow!

Edit: Al momento c’è la funzione setImmediate del nodo che pianifica la funzione da eseguire dopo gli eventi I / O in sospeso (come la gestione di nuove richieste Web): ho spiegato un caso d’uso nella risposta di questa domanda .