nodeJs richiama un semplice esempio

qualcuno può darmi un semplice esempio di callback di nodeJs, ho già cercato lo stesso su molti siti Web ma non sono in grado di comprenderlo correttamente, per favore dammi un semplice esempio.

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

Voglio fare qualcosa del genere ...

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

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

Ora apri il nodo o la console del browser e incolla le definizioni di cui sopra.

Infine usalo con questa riga successiva:

usingItNow(myCallback);

Rispetto alle convenzioni di errore stile nodo

Costa ha chiesto come sarebbe se si rispettassero le convenzioni di callback degli errori di nodo.

In questa convenzione, il callback dovrebbe aspettarsi di ricevere almeno un argomento, il primo argomento, come errore. Facoltativamente avremo uno o più argomenti aggiuntivi, a seconda del contesto. In questo caso, il contesto è il nostro esempio precedente.

Qui riscrivo il nostro esempio in questa convenzione.

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

Se vogliamo simulare un caso di errore, possiamo definire usingItNow in questo modo

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

L'utilizzo finale è esattamente lo stesso di sopra:

usingItNow(myCallback);

L'unica differenza di comportamento sarebbe subordinata alla versione di usingItNowche hai definito: quella che fornisce un "valore di verità" (un oggetto Error) al callback per il primo argomento, o quella che lo alimenta nullo per l'argomento di errore .

Una funzione di callback è semplicemente una funzione che passi a un'altra funzione in modo che la funzione possa chiamarla in un secondo momento. Questo è comunemente visto nelle API asincrone ; la chiamata API ritorna immediatamente perché è asincrona, quindi vi si passa una funzione che l'API può chiamare quando ha terminato di eseguire la sua attività asincrona.

L'esempio più semplice a cui posso pensare in JavaScript è la setTimeout()funzione. È una funzione globale che accetta due argomenti. Il primo argomento è la funzione di callback e il secondo argomento è un ritardo in millisecondi. La funzione è progettata per attendere la quantità di tempo appropriata, quindi richiamare la funzione di callback.

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

Potresti aver già visto il codice sopra, ma non ti sei reso conto che la funzione che stavi passando era chiamata funzione di callback. Potremmo riscrivere il codice sopra per renderlo più ovvio.

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

I callback vengono utilizzati ovunque in Node perché Node è costruito da zero per essere asincrono in tutto ciò che fa. Anche quando si parla al file system. Ecco perché un sacco di API del nodo interne accettano funzioni di callback come argomenti anziché restituire dati che puoi assegnare a una variabile. Invece richiamerà la tua funzione di callback, passando i dati che volevi come argomento. Ad esempio, potresti usare la fslibreria di Node per leggere un file. Il fsmodulo espone due funzioni API uniche: readFilee readFileSync.

La readFilefunzione è asincrona mentre readFileSyncovviamente non lo è. Puoi vedere che intendono che tu usi le chiamate asincrone quando possibile poiché le hanno chiamate readFilee readFileSyncinvece di readFilee readFileAsync. Ecco un esempio di utilizzo di entrambe le funzioni.

Sincrono:

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

Il codice precedente blocca l'esecuzione del thread fino a quando tutto il contenuto di test.txtviene letto in memoria e archiviato nella variabile data. Nel nodo questo è generalmente considerato una cattiva pratica. Ci sono volte però in cui è utile, come quando si scrive un breve script veloce per fare qualcosa di semplice ma noioso e non ti interessa molto risparmiare ogni nanosecondo di tempo che puoi.

Asincrono (con callback):

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

Per prima cosa creiamo una funzione di callback che accetta due argomenti erre data. Un problema con le funzioni asincrone è che diventa più difficile intercettare gli errori, quindi molte API in stile callback passano gli errori come primo argomento alla funzione di callback. È buona norma verificare se errha un valore prima di fare qualsiasi altra cosa. In tal caso, interrompere l'esecuzione della richiamata e registrare l'errore.

Le chiamate sincrone hanno un vantaggio quando vengono lanciate eccezioni perché puoi semplicemente catturarle con un try/catchblocco.

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

Nelle funzioni asincrone non funziona in questo modo. La chiamata API ritorna immediatamente, quindi non c'è nulla da catturare con il file try/catch. Le API asincrone corrette che utilizzano i callback rileveranno sempre i propri errori e quindi li trasmetteranno al callback dove potrai gestirlo come meglio credi.

Oltre ai callback, tuttavia, esiste un altro stile popolare di API comunemente utilizzato chiamato promessa. Se desideri leggere su di loro, puoi leggere l'intero post del blog che ho scritto sulla base di questa risposta qui .

Ecco un esempio di copia di file di testo con fs.readFilee 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);
  });
};

E questo è un esempio di utilizzo della copyFilefunzione:

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

Il pattern node.js comune suggerisce che il primo argomento della funzione di callback è un errore. È necessario utilizzare questo modello perché tutti i moduli del flusso di controllo si basano su di esso:

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

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

Prova questo esempio nel modo più semplice che puoi leggere, basta copiare save newfile.js fare node newfile per eseguire l'applicazione.

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

stiamo creando una semplice funzione come

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' è un modulo nodo che ti aiuta a leggere il file. La funzione di callback si assicurerà che il tuo file denominato "input.txt" venga letto completamente prima di essere eseguito. La funzione fs.stat () serve per ottenere informazioni sul file come la dimensione del file, la data di creazione e la data di modifica.

A callbackè una funzione passata come parametro a Higher Order Function( wikipedia ). Una semplice implementazione di una richiamata sarebbe:

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

Per chiamare la funzione, è sufficiente passare un'altra funzione come argomento alla funzione definita.

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

Questo post del blog ha una buona recensione:

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