nextTick vs setImmediate, explication visuelle

Je suis très confus sur les différences entre les nextTick et setImmediate. J'ai lu toute la documentation à leur sujet sur internet mais je ne comprends toujours pas comment ils fonctionnent.

Exemples:

function log(n) { console.log(n); }

setImmediate

setImmediate(function() {
  setImmediate(function() {
    log(1);
    setImmediate(function() { log(2); });
    setImmediate(function() { log(3); });
  });
  setImmediate(function() {
    log(4);
    setImmediate(function() { log(5); });
    setImmediate(function() { log(6); });
  });
});

//1 2 3 4 5 6

nextTick

process.nextTick(function() {
  process.nextTick(function() {
    log(1);
    process.nextTick(function() { log(2); });
    process.nextTick(function() { log(3); });
  });
  process.nextTick(function() {
    log(4);
    process.nextTick(function() { log(5); });
    process.nextTick(function() { log(6); });
  });
});

//1 4 2 3 5 6

Pourquoi ces résultats? Veuillez expliquer avec un visuel ou très facile de suivre les explications. Même le nœud de base devs ne sont pas d'accord sur la façon dont nextTick et setImmediate doit être compris par les gens.

Sources:

Grande question. C'est une excellente façon d'illustrer les différences.
Le résultat est le même (1 4 2 3 5 6) pour les deux exécutions (Nœud v5.6.0)
Sage et d'aider à la question!
à la fois produit de la même sortie
Regardez l'année, il y a 5 ans! Beaucoup de choses ont changé.

InformationsquelleAutor Gabriel Llamas | 2013-07-06

node.js

102

Considérons les deux exemples suivants:

setImmediate
```
setImmediate(function A() {
  setImmediate(function B() {
    log(1);
    setImmediate(function D() { log(2); });
    setImmediate(function E() { log(3); });
  });
  setImmediate(function C() {
    log(4);
    setImmediate(function F() { log(5); });
    setImmediate(function G() { log(6); });
  });
});

setTimeout(function timeout() {
  console.log('TIMEOUT FIRED');
}, 0)

//'TIMEOUT FIRED' 1 4 2 3 5 6
//OR
//1 'TIMEOUT FIRED' 4 2 3 5 6
```
nextTick
```
process.nextTick(function A() {
  process.nextTick(function B() {
    log(1);
    process.nextTick(function D() { log(2); });
    process.nextTick(function E() { log(3); });
  });
  process.nextTick(function C() {
    log(4);
    process.nextTick(function F() { log(5); });
    process.nextTick(function G() { log(6); });
  });
});

setTimeout(function timeout() {
  console.log('TIMEOUT FIRED');
}, 0)

//1 4 2 3 5 6 'TIMEOUT FIRED'
```
setImmediate rappels sont tirés hors de la boucle d'événements, une fois par itération dans l'ordre où ils ont été mis en file d'attente. Donc, à la première itération de la boucle d'événements, Un rappel est envoyé. Puis sur la deuxième itération de la boucle d'événements, de rappel B est déclenché, puis sur la troisième itération de la boucle d'événement de rappel C est tiré, etc. Cela empêche la boucle d'événement de blocage et permet à d'autres d'e/S ou de rappels de la minuterie d'être appelé dans le temps (comme c'est le cas de l'0ms expiration, qui est tiré sur la 1ère ou la 2ème itération de boucle).

nextTick rappels, cependant, sont toujours déclenché immédiatement après le code actuel est effectuée en cours d'exécution et AVANT de retourner à la boucle d'événements. Dans le nextTick exemple, nous nous retrouvons de l'exécution de toutes les nextTick rappels avant de revenir à la boucle d'événements. Depuis setTimeout du callback sera appelée à partir de la boucle d'événements, le message "DÉLAI d'attente FLAMME" ne sera pas de sortie jusqu'à ce que nous en avons terminé avec tous les nextTick de rappel.
- Parfait, le dernier paragraphe est la clé pour comprendre la différence principale.
- votre nextTick exemple est différent de sortie: TIMEOUT FIRED 1 4 2 3 5 6
- Quelle est la version de nœud êtes-vous en cours d'exécution? Sur le nœud de 0,10.x vous devriez toujours avoir votre nextTick rappels exécuter avant de frapper la boucle d'événements.
- Je souhaite qu'ils aient choisi un nom différent. Droit maintenant "nextTick" est plus immédiate que setImmediate.
- Avez-vous un exemple en rapport avec les I/O?
- franchement si le processus.nextTick ne pas retourner à la boucle d'événements, puis wtf est le point d'honneur. Si je voulais appeler une fonction à côté je viens de l'appeler explicitement par son nom. Rien d'étonnant à ce processus.nextTick est désapprouvée. J'ai toujours pensé que processus.nextTick fonctionné comme setImmediate la réalité. processus.nextTick est alors une immense erreur.
- Je suis de savoir ce que tu veux dire. Il y a un exemple dans la doc qui explique un possible cas d'utilisation. nodejs.org/api/process.html#process_process_nexttick_callback
- désolé de vous embêter après une longue période de temps . Je suis un débutant de node.js. Juste pour clarifier les raisons de A, puis B,puis C,puis D et E, alors F et G des rappels ont été appelés dans l'ordre ? Pourquoi ne pas A,B,D,E,C,F,G ?
- Parce que quand Un s'exécute, il les ensembles B et C seront programmées suivant. Lorsque B exécute des ensembles D et E à l'être prévue à côté, mais C est déjà programmée pour l'après-B. Rappelez-vous qu'il existe une différence entre le moment où la fonction de rappel est prévue ou inscrite et lorsque le rappel fait feux de.
- dans setImmediate je pense que B et C sont poussés à check queue dans la même itération parce que le JS est run to complete
- Oui @Guichi Vous avez absolument raison. B et C prévue à l'occasion d'Une() Callaback exécution.
InformationsquelleAutor Dave Stibrany
23

Selon l'Node.js doc noms de ces deux fonction sont exactement inversés

setImmediate() (RECOMMANDÉ de)

C'est le premier feu à la file d'attente d'événements

processus.nextTick() (UTILISER POUR des CAS particuliers, voir l'exemple plus tard)

C'est le feu, C'est un peu écrire une déclaration de plus à la fin du fichier en cours

Si nous avons ce code
```
setTimeout(function(){
  console.log('Hello world 5'); //It's waiting like a normal person at a queue
}, 0);

setImmediate(function(){
  console.log('Hello world 4'); 
  //It's like get to last and be take care of first 
  //but always after of .nextTick and before of setInterval(, 0)
});

process.nextTick(function(){
   console.log('Hello world 3'); //It's like be at the bottom at this file
});

console.log('Hello world 1');
console.log('Hello world 2');
```
Une explication visuelle selon votre demande:

Cas pour le processus d'utilisation.nextTick() lorsque vous avez à émettre et le cas avant pour la gérer:
```
const EventEmitter = require('events');
const util = require('util');

function MyEmitter() {
  EventEmitter.call(this);

  //use nextTick to emit the event once a handler is assigned
  process.nextTick(function () {
    this.emit('event');
  }.bind(this));
}
util.inherits(MyEmitter, EventEmitter);

const myEmitter = new MyEmitter();
myEmitter.on('event', function() {
  console.log('an event occurred!');
});
```
Regarder ce vide où Philippe Roberts nous donner une bonne explication à propos d'exécution boucle d'événement et de regarder cela en ligne eventloop débogueur Test en direct comment la boucle d'événement de travaux

Source:
https://github.com/nodejs/node/blob/master/doc/topics/the-event-loop-timers-and-nexttick.md#processnexttick-vs-setimmediate
- Cette réponse a plus de sens! Merci @gsalgadotoledo :p l'homme, il est encore plus difficile à écrire votre prénom et votre nom compréhension nextTick et setImmediate.
InformationsquelleAutor gsalgadotoledo
8

Je ne peux pas reproduire vos résultats pour setImmediate. Il doit être le même que nextTick (et il est dans mes tests), car dans cette situation, ils font à peu près la même chose. La seule explication raisonnable est que les setImmediate est d'une certaine manière synchrone, mais il ne l'est pas.

Et selon NodeJS documentation la seule vraie différence est le fait que plusieurs nextTick feu dans une boucle d'itération (selon maxTickDepth), tandis que setImmediate feux une fois par itération.

InformationsquelleAutor freakish
3

Ci-dessous vous donne une meilleure clarté.

setImmediate
1. Il execute un script une fois le sondage la phase se termine.
2. C'est une minuterie fonction des modules et des fonctions de minuterie sont globaux, vous pouvez les appeler sans require.
3. Il peut effacé par clearImmediate().
4. Ensemble "immédiate" de l'exécution de la fonction de rappel après I/O événements " rappels avant de setTimeout() et setInterval().
nextTick
1. C'est un processus global de la fonction de l'objet de NodeJS.
2. Tous les rappels passé à traiter.nextTick (), doit être réglé avant l'événement boucle continue.
3. Permettre aux utilisateurs de gérer les erreurs.
4. Permet d'essayer à nouveau la demande avant l'événement boucle continue.
Simple Extrait de code.
```
console.log("I'm First");

setImmediate(function () {
  console.log('Im setImmediate');
});

console.log("I'm Second");

process.nextTick(function () {
  console.log('Im nextTick');
});

console.log("I'm Last");

/*
Output
$ node server.js
I'm First
I'm Second
I'm Last
Im nextTick
Im setImmediate
*/
```
InformationsquelleAutor Venkat.R
2

Je pense que toutes les réponses ci-dessus sont obsolètes, parce que j'ai eu des réponses différentes en permanence avec la version actuelle de nodejs et il est facile de raisonner sur
```
var log=console.log
log(process.version)

var makeAsyncCall
if(false)
    makeAsyncCall=setImmediate
else
    makeAsyncCall=process.nextTick;

makeAsyncCall(function A () {
    makeAsyncCall(function B() {
        log(1);
        makeAsyncCall(function C() { log(2); });
        makeAsyncCall(function D() { log(3); });
    });
    makeAsyncCall(function E() {
        log(4);
        makeAsyncCall(function F() { log(5); });
        makeAsyncCall(function G() { log(6); });
    });
});
//1
//4
//2
//3
//5
//6
//in both case
```
Après la lecture de https://github.com/nodejs/node/blob/master/doc/topics/the-event-loop-timers-and-nexttick.md#processnexttick-vs-setimmediate
laissez démarrer utiliser de setImmediate nous devrions garder une trace de la check queue car c'est là que le setImmediate rappel résident.

Première itération

A est de pousser à check queue

file d'attente de vérification :[A]

Deuxième itération

A est de sortir de queue pour exécuter

Au cours de son exécution ,il a mis B et E à queueet puis, A complet et commencer la prochaine itération

file d'attente de vérification :[B,E]

Troisième itération

sortir B et pousser C D

file d'attente de vérification :[E,C,D]

De suite itération

sortir E et pousser F G

file d'attente de vérification : [C,D,F,G]

Enfin

exécuter les rappels dans la file d'attente de manière séquentielle

Pour nextTick cas, la file d'attente fonctionne exactement de la même manière,c'est pourquoi il produire le même résultat

La différence est que :

la nextTickQueue sera traitée après l'opération en cours
terminée, indépendamment de la phase actuelle de la boucle d'événement de

Pour être clair,la boucle d'événement de maintenir de multiples files d'attente et check queue est juste l'un d'eux,le nœud décidera de la file d'attente à utiliser en fonction de certaines règles

avec process.nextTick cependant,il est une sorte de contournement de la tous la règle et exécuter le rappel dans nextTick immédiatement

InformationsquelleAutor Guichi

Vous devez vous connecter pour publier un commentaire.

setImmediate

nextTick

Simple Extrait de code.