Warum und wann process.nextTick verwenden?

Question

Unten ist der Code in "practise01.js" Datei,

function fn(name){ 
    return f; 

    function f(){ 
     var n = name; 
     console.log("Next TICK "+n+", ");   
    } 
} 

function myTimeout(time,msg){ 
    setTimeout(function(){ 
     console.log("TIMEOUT "+msg); 
    },time); 
} 

process.nextTick(fn("ONE")); 
myTimeout(500,"AFTER-ONE"); 
process.nextTick(fn("TWO")); 
myTimeout(500,"AFTER-TWO"); 
process.nextTick(fn("THREE")); 
myTimeout(500,"AFTER-THREE"); 
process.nextTick(fn("FOUR")); 

Der Ausgang obigen Code vom Laufen ist

rahul@rahul:~/myPractise/PlainNodeJSPractise01/Process$ node practise01.js     

Next TICK ONE, 
Next TICK TWO, 
Next TICK THREE, 
Next TICK FOUR, 
TIMEOUT AFTER-ONE 
TIMEOUT AFTER-TWO 
TIMEOUT AFTER-THREE 

Jetzt habe ich den Code geschrieben, ohne process.nextTick zu verwenden, in „practise02 Js“, as,

function myTimeout(time,msg){ 
    setTimeout(function(){ 
     console.log("TIMEOUT "+msg); 
    },time); 
} 

function fn(name){ 
    return f; 

    function f(){ 
    var n = name; 
    console.log("Next TICK "+n+", ");  
    } 
} 

fn("ONE")(); 
myTimeout(500,"AFTER-ONE"); 
fn("TWO")(); 
myTimeout(500,"AFTER-TWO"); 
fn("THREE")(); 
myTimeout(500,"AFTER-THREE"); 
fn("FOUR")(); 

nach dem obigen Code die Ausgabe läuft

folgt

rahul@rahul:~/myPractise/PlainNodeJSPractise01/Process$ node practise02.js 
Next TICK ONE, 
Next TICK TWO, 
Next TICK THREE, 
Next TICK FOUR, 
TIMEOUT AFTER-ONE 
TIMEOUT AFTER-TWO 
TIMEOUT AFTER-THREE 

Wenn Sie sehen, sind beide Ausgänge gleich.

Also in diesem Fall muss ich mit process.nextTick gehen?

Wenn ich versuchte mehr zu lesen, was ich zu verstehen gelernt habe, ist Wenn ich eine Funktion sofort ausführen muss, wenn die Eventloop leer ist als für "process.nextTick" gehen.

Also, wie unterscheidet es sich von meinem zweiten Ansatz.

Bitte erklären Sie mir oder rufen Sie mich einige Hinweise

Answer 1

Sie haben Ihre Antwort in einem Beitrag in dem Sie Ihre Ausgabe mit uns teilen:

rahul@rahul:~/myPractise/PlainNodeJSPractise01/Process$ node practise02.js 
Next TICK ONE, 
Next TICK TWO, 
Next TICK THREE, 
Next TICK FOUR, 
TIMEOUT AFTER-ONE 
TIMEOUT AFTER-TWO 
TIMEOUT AFTER-THRE 

Wenn wir 500-0 noch Ihre Timeout-Zeit ändern gleiches Ergebnis:

function fn(name){ 
 
    return f; 
 

 
    function f(){ 
 
     var n = name; 
 
     console.log("Next TICK "+n+", "); 
 
    } 
 
} 
 

 
function myTimeout(time,msg){ 
 
    setTimeout(function(){ 
 
     console.log("TIMEOUT "+msg); 
 
    },time); 
 
} 
 

 
process.nextTick(fn("ONE")); 
 
myTimeout(0,"AFTER-ONE");// set timeout to execute in 0 seconds for all 
 
process.nextTick(fn("TWO")); 
 
myTimeout(0,"AFTER-TWO"); 
 
process.nextTick(fn("THREE")); 
 
myTimeout(0,"AFTER-THREE"); 
 
process.nextTick(fn("FOUR"));

Ergebnisse

Next TICK ONE, 
Next TICK TWO, 
Next TICK THREE, 
Next TICK FOUR, 
TIMEOUT AFTER-ONE 
TIMEOUT AFTER-TWO 
TIMEOUT AFTER-THREE 

wenn Sie process.nextTick Sie grundsätzlich sicher, dass die Funktion, die Sie als Parameter übergeben wird sofort in der nächsten Tick dh aufgerufen werden. Start der nächsten Event-Schleife. Deshalb werden alle Ihre Funktionen im nächsten Tick vor Ihrem Timer ausgeführt, dh. setTimeout nächstes Häkchen bedeutet nicht nächste Sekunde, es bedeutet nächste Schleife des nodejs eventloop. Der nächste Tick stellt außerdem sicher, dass die Funktion, die Sie aufrufen möchten, asynchron ausgeführt wird. Und der nächste Tick hat eine höhere Priorität als Ihre Timer, E/A-Operationen usw., die in der Ereignisschleife zur Ausführung in die Warteschlange gestellt werden. Sie sollten nextTick verwenden, wenn Sie sicherstellen möchten, dass der Code zu Beginn der nächsten Ereignisschleife statt nach einer bestimmten Zeit ausgeführt wird. nextTick ist effizienter als Timer und wenn Sie sicherstellen möchten, dass die aufgerufene Funktion asynchron ausgeführt wird. Sie können weitere Informationen zu diesem Thema in NodeJS docs

Answer 2

Der Knoten Dokumentation zu erklären, wenn eigentlich ziemlich gut ist und warum mit nextTick:

https://nodejs.org/api/process.html#process_process_nexttick_callback_args

Was es tut:

Dies ist kein einfacher Alias ​​für setTimeout (fn, 0), es ist viel effizienter. Es wird ausgeführt, bevor zusätzliche E/A-Ereignisse (einschließlich Timer) in nachfolgenden Ticks der Ereignisschleife ausgelöst werden.

und wenn zu verwenden:

Dies ist wichtig, wenn APIs, um die Entwicklung die Möglichkeit zu geben, die Benutzern Event-Handler zuweisen, nachdem ein Objekt konstruiert wurde, aber vor jedem I/O aufgetreten ..

.

function definitelyAsync(arg, cb) { 
    if (arg) { 
    process.nextTick(cb); 
    return; 
    } 

    fs.stat('file', cb); 
} 
definitelyAsync(true,() => { 
    foo(); 
}); 
bar(); // will now allways be called before foo()