nodeJs callbacks einfaches beispiel

Question

kann mir jemand ein einfaches beispiel für nodeJs callbacks geben, ich habe schon auf vielen webseiten dasselbe gesucht aber nicht in der lage das richtig zu verstehen, bitte gib mir ein einfaches beispiel.

getDbFiles(store, function(files){ 
    getCdnFiles(store, function(files){ 
    }) 
}) 

Ich möchte so etwas tun ...

Answer 1

var myCallback = function(data) { 
    console.log('got data: '+data); 
}; 

var usingItNow = function(callback) { 
    callback('get it?'); 
}; 

jetzt offen Knoten oder Browser-Konsole und die oben genannten Definitionen einfügen.

verwenden sie schließlich mit dieser nächsten Zeile:

usingItNow(myCallback); 

Mit Bezug auf die Knoten-Style Fehler Konventionen

Costa fragte, wie dies aussehen würde, wenn wir den Knoten Fehler-Callback zu ehren Konventionen.

In dieser Konvention sollte der Rückruf erwarten, mindestens ein Argument, das erste Argument, als Fehler zu erhalten. Optional haben wir je nach Kontext ein oder mehrere zusätzliche Argumente. In diesem Fall ist der Kontext das obige Beispiel.

Hier schreibe ich unser Beispiel in dieser Konvention um.

var myCallback = function(err, data) { 
    if (err) throw err; // Check for the error and throw if it exists. 
    console.log('got data: '+data); // Otherwise proceed as usual. 
}; 

var usingItNow = function(callback) { 
    callback(null, 'get it?'); // I dont want to throw an error, so I pass null for the error argument 
}; 

Wenn wir einen Fehler Fall simulieren wollen, können wir usingItNow wie diese

var usingItNow = function(callback) { 
    var myError = new Error('My custom error!'); 
    callback(myError, 'get it?'); // I send my error as the first argument. 
}; 

Die endgültige Nutzung definieren ist genau die gleiche wie oben:

usingItNow(myCallback); 

Der einzige Unterschied Das Verhalten hängt davon ab, welche Version von usingItNow Sie definiert haben: die, die einen "truthigen Wert" (ein Error-Objekt) an den Callback für das erste Argument oder den Feed eingibt Es ist null für das Fehlerargument. Hier

Answer 2

ist ein Beispiel für das Kopieren Textdatei mit fs.readFile und fs.writeFile:

var fs = require('fs'); 

var copyFile = function(source, destination, next) { 
    // we should read source file first 
    fs.readFile(source, function(err, data) { 
    if (err) return next(err); // error occurred 
    // now we can write data to destination file 
    fs.writeFile(destination, data, next); 
    }); 
}; 

Und das ist ein Beispiel der Verwendung copyFile Funktion:

copyFile('foo.txt', 'bar.txt', function(err) { 
    if (err) { 
    // either fs.readFile or fs.writeFile returned an error 
    console.log(err.stack || err); 
    } else { 
    console.log('Success!'); 
    } 
}); 

Gemeinsame node.js Muster legt nahe, dass das erste Argument der Rückruffunktion ist ein Fehler. Sie sollen dieses Muster verwenden, da alle Steuer Flow-Module darauf verlassen:

next(new Error('I cannot do it!')); // error 

next(null, results); // no error occurred, return result 

Answer 3

Ein Callback-Funktion ist einfach eine Funktion, die Sie in einer anderen Funktion übergeben, so dass Funktion es zu einem späteren Zeitpunkt aufrufen kann. Dies wird üblicherweise in asynchronen API s gesehen; Der API-Aufruf wird sofort zurückgegeben, da er asynchron ist. Sie übergeben also eine Funktion, die die API aufrufen kann, wenn die asynchrone Task ausgeführt wurde. Das einfachste Beispiel, das ich mir in JavaScript vorstellen kann, ist die setTimeout()-Funktion. Es ist eine globale Funktion, die zwei Argumente akzeptiert. Das erste Argument ist die Callback-Funktion und das zweite Argument ist eine Verzögerung in Millisekunden.Die Funktion ist so konzipiert, dass sie die entsprechende Zeitspanne wartet und anschließend die Rückruffunktion aufruft.

setTimeout(function() { 
    console.log("10 seconds later..."); 
}, 10000); 

Möglicherweise haben Sie den obigen Code vor gesehen, aber nur nicht erkennen, die Funktion, die Sie in eine Callback-Funktion aufgerufen wurde vorbei waren. Wir könnten den obigen Code umschreiben, um es deutlicher zu machen.

var callback = function() { 
    console.log("10 seconds later..."); 
}; 
setTimeout(callback, 10000); 

Rückrufe sind überall in Knoten verwendet, da Knoten aus dem Boden aufgebaut wird in alles asynchron zu sein, der es tut. Auch im Gespräch mit dem Dateisystem. Aus diesem Grund akzeptieren viele der internen Node-APIs Rückruffunktionen als Argumente und geben keine Daten zurück, die Sie einer Variablen zuweisen können. Stattdessen ruft es Ihre Callback-Funktion auf und übergibt die gewünschten Daten als Argument. Zum Beispiel könnten Sie die fs-Bibliothek von Node verwenden, um eine Datei zu lesen. Das Modul fs bietet zwei einzigartige API-Funktionen: readFile und readFileSync.

Die readFile Funktion ist asynchron, während readFileSync offensichtlich nicht ist. Sie können sehen, dass Sie die asynchronen Aufrufe so oft wie möglich verwenden möchten, da sie readFile und readFileSync anstelle von readFile und readFileAsync genannt wurden. Hier ist ein Beispiel für die Verwendung beider Funktionen.

Synchron:

var data = fs.readFileSync('test.txt'); 
console.log(data); 

Der obige Code Ausführungsblöcke Thread, bis der gesamte Inhalt des test.txt werden in den Speicher gelesen und in der Variablen data gespeichert. Im Knoten wird dies typischerweise als schlechte Praxis angesehen. Es gibt jedoch Zeiten, in denen es nützlich ist, zum Beispiel wenn man ein kleines Skript schreibt, um etwas Einfaches, aber Langweiliges zu tun, und es dir nicht so wichtig ist, jede Nanosekunde Zeit zu sparen, die du kannst.

Asynchronous (mit Rückruf):

var callback = function (err, data) { 
    if (err) return console.error(err); 
    console.log(data); 
}; 
fs.readFile('test.txt', callback); 

Zuerst erstellen wir eine Callback-Funktion, die zwei Argumente err und data akzeptiert. Ein Problem mit asynchronen Funktionen besteht darin, dass es schwieriger wird, Fehler einzufangen, so dass viele Callback-APIs Fehler als erstes Argument an die Callback-Funktion übergeben. Es empfiehlt sich, zu überprüfen, ob err einen Wert hat, bevor Sie etwas anderes tun. Ist dies der Fall, beenden Sie die Ausführung des Rückrufs und protokollieren Sie den Fehler.

Synchrone Aufrufe haben einen Vorteil, wenn Ausnahmen ausgelöst werden, weil Sie sie einfach mit einem Block abfangen können.

In asynchronen Funktionen funktioniert es nicht so. Der API-Aufruf kehrt sofort zurück, so dass nichts mit der try/catch zu fangen ist. Ordnungsgemäße asynchrone APIs, die Rückrufe verwenden, werden immer ihre eigenen Fehler abfangen und diese Fehler dann an den Rückruf weitergeben, wo Sie sie nach eigenem Ermessen behandeln können.

Zusätzlich zu den Callbacks gibt es einen anderen populären API-Stil, der häufig als "Promise" bezeichnet wird. Wenn Sie über sie lesen möchten, können Sie den gesamten Blogpost lesen, den ich basierend auf dieser Antwort geschrieben habe here.

Answer 4

Versuchen Sie dieses Beispiel so einfach wie Sie lesen können, kopieren Sie einfach save newfile.js tun Knoten newfile, um die Anwendung auszuführen.

function myNew(next){ 
    console.log("Im the one who initates callback"); 
    next("nope", "success"); 
} 


myNew(function(err, res){ 
    console.log("I got back from callback",err, res); 
}); 

Answer 5

wir eine einfache Funktion als

Schaffung

callBackFunction (data, function (err, response){ 
    console.log(response) 
}) 

// callbackfunction 
function callBackFuntion (data, callback){ 
    //write your logic and return your result as 
callback("",result) //if not error 
callback(error, "") //if error 
}