nodeJs callbacks eenvoudig voorbeeld

Kan iemand me een eenvoudig voorbeeld geven van nodeJs-callbacks, ik heb al op veel websites naar hetzelfde gezocht, maar kan het niet goed begrijpen. Geef me een eenvoudig voorbeeld.

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

Ik wil zoiets doen…

Antwoord 1, autoriteit 100%

var myCallback = function(data) {
  console.log('got data: '+data);
};
var usingItNow = function(callback) {
  callback('get it?');
};

Open nu de node of browserconsole en plak de bovenstaande definities.

Gebruik het ten slotte met deze volgende regel:

usingItNow(myCallback);

Met betrekking tot de conventies voor knooppuntstijlfouten

Costa vroeg hoe dit eruit zou zien als we de callback-conventies voor node-fouten zouden respecteren.

In deze conventie moet de callback verwachten dat hij ten minste één argument, het eerste argument, als een fout ontvangt. Optioneel zullen we een of meer aanvullende argumenten hebben, afhankelijk van de context. In dit geval is de context ons bovenstaande voorbeeld.

Hier herschrijf ik ons voorbeeld in deze conventie.

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
};

Als we een foutcase willen simuleren, kunnen we PUNTIONNUEK zo definiëren

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

Het uiteindelijke gebruik is precies hetzelfde als hierboven:

usingItNow(myCallback);

Het enige verschil in gedrag zou contingent zijn op welke versie van usingItNowU hebt gedefinieerd: Degene die een “waarheidige waarde” (een foutobject) voedt met de terugslag voor het eerste argument, of degene die het null geeft voor het foutargument.

Antwoord 2, Autoriteit 56%

Een callback-functie is gewoon een functie die u in een andere functie passeert, zodat de functie het op een later tijdstip kan noemen. Dit wordt vaak gezien in asynchronous api s; De API-oproep keert onmiddellijk terug omdat het asynchroon is, dus je passeert er een functie in die de API kan bellen wanneer het klaar is met het uitvoeren van zijn asynchrone taak.

Het eenvoudigste voorbeeld dat ik kan bedenken in JavaScript is de setTimeout()functie. Het is een wereldwijde functie die twee argumenten accepteert. Het eerste argument is de callback-functie en het tweede argument is een vertraging in milliseconden. De functie is ontworpen om de juiste hoeveelheid tijd te wachten en vervolgens uw callback-functie aan te roepen.

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

Je hebt de bovenstaande code misschien eerder gezien, maar realiseerde je niet dat de functie die je doorgaf een callback-functie werd genoemd. We zouden de bovenstaande code kunnen herschrijven om het duidelijker te maken.

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

Callbacks worden overal in Node gebruikt omdat Node vanaf de grond af is opgebouwd om asynchroon te zijn in alles wat het doet. Zelfs wanneer u met het bestandssysteem praat. Dat is de reden waarom een heleboel interne Node-API’s callback-functies als argumenten accepteren in plaats van gegevens te retourneren die u aan een variabele kunt toewijzen. In plaats daarvan zal het uw callback-functie aanroepen, waarbij de gewenste gegevens als argument worden doorgegeven. U kunt bijvoorbeeld de fs-bibliotheek van Node gebruiken om een bestand te lezen. De module fsbiedt twee unieke API-functies: readFileen readFileSync.

De functie readFileis asynchroon terwijl readFileSyncdat duidelijk niet is. Je kunt zien dat ze van plan zijn om de async-aanroepen waar mogelijk te gebruiken, omdat ze ze readFileen readFileSyncnoemden in plaats van readFileen readFileAsync. Hier is een voorbeeld van het gebruik van beide functies.

Synchroon:

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

De bovenstaande code blokkeert de uitvoering van de thread totdat alle inhoud van test.txtin het geheugen is ingelezen en is opgeslagen in de variabele data. In node wordt dit doorgaans als een slechte gewoonte beschouwd. Er zijn echter momenten waarop het nuttig is, zoals bij het schrijven van een snel klein script om iets eenvoudigs maar vervelends te doen en het u niet veel kan schelen om elke nanoseconde tijd te besparen die u kunt.

Asynchroon (met terugbellen):

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

Eerst maken we een callback-functie die twee argumenten erren dataaccepteert. Een probleem met asynchrone functies is dat het moeilijker wordt om fouten op te vangen, dus veel API’s in callback-stijl geven fouten door als het eerste argument voor de callback-functie. Het is het beste om te controleren of erreen waarde heeft voordat u iets anders doet. Als dit het geval is, stop dan de uitvoering van de callback en log de fout in.

Synchrone oproepen hebben een voordeel wanneer er uitzonderingen worden gegenereerd, omdat u ze eenvoudig kunt opvangen met een try/catch-blok.

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

In asynchrone functies werkt het niet zo. De API-aanroep keert onmiddellijk terug, dus er valt niets te vangen met de try/catch. De juiste asynchrone API’s die callbacks gebruiken, vangen altijd hun eigen fouten op en geven die fouten vervolgens door aan de callback, waar u deze naar eigen inzicht kunt afhandelen.

Naast callbacks is er echter nog een populaire stijl van API die vaak wordt gebruikt, de belofte genoemd. Als je over hen wilt lezen, kun je het hele blogpost lezen dat ik schreef op basis van dit antwoord hier .

Antwoord 3, Autoriteit 5%

Hier is een voorbeeld van het kopiëren van tekstbestand met fs.readFileen 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);
  });
};

En dat is een voorbeeld van het gebruik van copyFileFUNCTION:

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

Common Node.JS-patroon suggereert dat het eerste argument van de callback-functie een fout is. U moet dit patroon gebruiken omdat alle bedieningsstroommodules erop vertrouwen:

next(new Error('I cannot do it!')); // error
next(null, results); // no error occurred, return result

Antwoord 4, Autoriteit 3%

Probeer dit voorbeeld zo eenvoudig als je kunt lezen, gewoon opslaan NewFile.js Do Node NewFile uitvoeren om de applicatie uit te voeren.

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

Antwoord 5

We maken een eenvoudige functie 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
}

Antwoord 6

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’ is een knooppuntmodule die u helpt om het bestand te lezen.
Callback-functie zorgt ervoor dat uw bestand met de naam ‘Input.txt’ volledig is gelezen voordat het wordt uitgevoerd.
Fs.Sstat () -functie is om bestandsinformatie zoals bestandsgrootte, aangemaakte datum en datum te krijgen.

Antwoord 7

//delay callback function
function delay (seconds, callback){
    setTimeout(() =>{
      console.log('The long delay ended');
      callback('Task Complete');
    }, seconds*1000);
}
//Execute delay function
delay(1, res => {  
    console.log(res);  
})

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

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

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