NodeJs Callbacks einfaches Beispiel

Kann mir jemand ein einfaches Beispiel für die Rückrufe von NodeJs geben? Ich habe bereits auf vielen Websites danach gesucht, kann es aber nicht richtig verstehen. Bitte geben Sie mir ein einfaches Beispiel.

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

Ich möchte so etwas tun ...

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

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

Öffnen Sie nun die Knoten- oder Browserkonsole und fügen Sie die obigen Definitionen ein.

Verwenden Sie es schließlich mit dieser nächsten Zeile:

usingItNow(myCallback);

In Bezug auf die Fehlerkonventionen im Knotenstil

Costa fragte, wie dies aussehen würde, wenn wir die Rückrufkonventionen für Knotenfehler einhalten würden.

In dieser Konvention sollte der Rückruf mindestens ein Argument, das erste Argument, als Fehler erhalten. Optional haben wir je nach Kontext ein oder mehrere zusätzliche Argumente. In diesem Fall ist der Kontext unser obiges 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 Fehlerfall simulieren möchten, können wir dies mit ItNow wie folgt definieren

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 Verwendung ist genau die gleiche wie oben:

usingItNow(myCallback);

Der einzige Unterschied im Verhalten usingItNowhängt davon ab, welche Version von Ihnen definiert wurde: diejenige, die dem Rückruf für das erste Argument einen "wahrheitsgemäßen Wert" (ein Fehlerobjekt) zuführt, oder diejenige, die ihn für das Fehlerargument mit null füttert .

Eine Rückruffunktion ist einfach eine Funktion, die Sie an eine andere Funktion übergeben, damit diese Funktion sie zu einem späteren Zeitpunkt aufrufen kann. Dies tritt häufig bei asynchronen APIs auf . Der API-Aufruf wird sofort zurückgegeben, da er asynchron ist. Sie übergeben ihm also eine Funktion, die die API aufrufen kann, wenn die asynchrone Aufgabe 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 Rückruffunktion und das zweite Argument ist eine Verzögerung in Millisekunden. Die Funktion wartet die entsprechende Zeit und ruft dann Ihre Rückruffunktion auf.

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

Möglicherweise haben Sie den obigen Code schon einmal gesehen, aber nicht bemerkt, dass die Funktion, die Sie übergeben haben, als Rückruffunktion bezeichnet wurde. Wir könnten den obigen Code umschreiben, um ihn offensichtlicher zu machen.

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

Rückrufe werden überall in Node verwendet, da Node von Grund auf so aufgebaut ist, dass es bei allem, was es tut, asynchron ist. Auch wenn Sie mit dem Dateisystem sprechen. Aus diesem Grund akzeptieren eine Tonne der internen Knoten-APIs Rückruffunktionen als Argumente, anstatt Daten zurückzugeben, die Sie einer Variablen zuweisen können. Stattdessen wird Ihre Rückruffunktion aufgerufen und die gewünschten Daten als Argument übergeben. Sie können beispielsweise die Knotenbibliothek fszum Lesen einer Datei verwenden. Das fsModul stellt zwei eindeutige API-Funktionen zur Verfügung: readFileund readFileSync.

Die readFileFunktion ist asynchron, während dies readFileSyncoffensichtlich nicht der Fall ist. Sie können sehen, dass sie beabsichtigen, die asynchronen Aufrufe zu verwenden, wann immer dies möglich ist, da sie sie aufgerufen haben readFileund readFileSyncanstelle von readFileund readFileAsync. Hier ist ein Beispiel für die Verwendung beider Funktionen.

Synchron:

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

Der obige Code blockiert die Thread-Ausführung, bis der gesamte Inhalt von test.txtin den Speicher eingelesen und in der Variablen gespeichert wurde data. Im Knoten wird dies normalerweise als schlechte Praxis angesehen. Es gibt jedoch Situationen, in denen es nützlich ist, z. B. wenn Sie ein schnelles kleines Skript schreiben, um etwas Einfaches, aber Mühsames zu tun, und es Ihnen nicht wichtig ist, jede Nanosekunde Zeit zu sparen, die Sie können.

Asynchron (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 Rückruffunktion, die zwei Argumente akzeptiert err unddata . Ein Problem bei asynchronen Funktionen besteht darin, dass es schwieriger wird, Fehler abzufangen, sodass viele APIs im Rückrufstil Fehler als erstes Argument an die Rückruffunktion übergeben. Es wird empfohlen, zu überprüfen, ob errein Wert vorliegt, bevor Sie etwas anderes tun. Wenn ja, beenden Sie die Ausführung des Rückrufs und protokollieren Sie den Fehler.

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

try {
  var data = fs.readFileSync('test.txt');
  console.log(data);
} catch (err) {
  console.error(err);
}

In asynchronen Funktionen funktioniert das nicht so. Der API-Aufruf wird sofort zurückgegeben, sodass mit dem nichts zu fangen ist try/catch. Richtige asynchrone APIs, die Rückrufe verwenden, erkennen immer ihre eigenen Fehler und übergeben diese Fehler dann an den Rückruf, wo Sie sie nach Belieben behandeln können.

Zusätzlich zu Rückrufen gibt es jedoch einen anderen beliebten API-Stil, der häufig als Versprechen bezeichnet wird. Wenn Sie darüber lesen möchten, können Sie den gesamten Blog-Beitrag lesen, den ich basierend auf dieser Antwort hier geschrieben habe .

Hier ist ein Beispiel für das Kopieren von Textdateien mit fs.readFileund 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 für die Verwendung von copyFileFunktionen:

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!');
  }
});

Das allgemeine Muster node.js legt nahe, dass das erste Argument der Rückruffunktion ein Fehler ist. Sie sollten dieses Muster verwenden, da alle Kontrollflussmodule darauf angewiesen sind:

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

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

Versuchen Sie dieses Beispiel so einfach wie möglich zu lesen. Kopieren Sie einfach save newfile.js do node 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);
});

Wir erstellen eine einfache Funktion als

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
}

const fs = require('fs');

fs.stat('input.txt', function (err, stats) {
    if(err){
        console.log(err);
    } else {
        console.log(stats);
        console.log('Completed Reading File');
    }
});

'fs' ist ein Knotenmodul, mit dem Sie Dateien lesen können. Die Rückruffunktion stellt sicher, dass Ihre Datei mit dem Namen 'input.txt' vollständig gelesen wird, bevor sie ausgeführt wird. Mit der Funktion fs.stat () werden Dateiinformationen wie Dateigröße, Erstellungsdatum und Änderungsdatum abgerufen.

A callbackist eine Funktion, die als Parameter an a Higher Order Function( Wikipedia ) übergeben wird. Eine einfache Implementierung eines Rückrufs wäre:

const func = callback => callback('Hello World!');

Um die Funktion aufzurufen, übergeben Sie einfach eine andere Funktion als Argument an die definierte Funktion.

func(string => console.log(string));

Dieser Blog-Beitrag hat eine gute Zusammenfassung:

https://codeburst.io/javascript-what-the-heck-is-a-callback-aba4da2deced

function doHomework(subject, callback) {
  alert(`Starting my ${subject} homework.`);
  callback();
}

function alertFinished(){
  alert('Finished my homework');
}

doHomework('math', alertFinished);