exemplo simples de callbacks do nodeJs

Alguém pode me dar um exemplo simples de callbacks nodeJs, eu já procurei o mesmo em muitos sites, mas não é capaz de compreendê-lo corretamente, por favor me dê um exemplo simples.

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

Eu quero fazer algo assim…

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

    Agora abra o nó ou o console do navegador e cole as definições acima.

    Finalmente use-o com esta próxima linha:

     usingItNow(myCallback); 

    Com respeito às convenções de erro em estilo de nó

    Costa perguntou como isso seria se fôssemos honrar as convenções de retorno de chamada do erro do nó.

    Nesta convenção, o retorno de chamada deve esperar receber pelo menos um argumento, o primeiro argumento, como um erro. Opcionalmente, teremos um ou mais argumentos adicionais, dependendo do contexto. Neste caso, o contexto é o nosso exemplo acima.

    Aqui eu reescrevo nosso exemplo nesta convenção.

     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 quisermos simular um caso de erro, podemos definir usingItNow assim

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

    O uso final é exatamente o mesmo que acima:

     usingItNow(myCallback); 

    A única diferença no comportamento seria contingente em qual versão de usingItNow você definiu: aquele que alimenta um “valor geral” (um object Error) para o retorno de chamada para o primeiro argumento, ou aquele que o alimenta nulo para o erro argumento.

    Uma function de retorno de chamada é simplesmente uma function que você passa para outra function, de modo que a function possa chamá-la posteriormente. Isso é comumente visto em APIs assíncronas; a chamada da API retorna imediatamente porque é assíncrona, então você passa uma function para ela que a API pode chamar quando estiver executando sua tarefa assíncrona.

    O exemplo mais simples que posso pensar em JavaScript é a function setTimeout() . É uma function global que aceita dois argumentos. O primeiro argumento é a function de retorno de chamada e o segundo argumento é um atraso em milissegundos. A function foi projetada para aguardar a quantidade adequada de tempo e, em seguida, chamar sua function de retorno de chamada.

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

    Você pode ter visto o código acima antes, mas simplesmente não percebeu que a function que estava passando era chamada de function de retorno de chamada. Poderíamos rewrite o código acima para torná-lo mais óbvio.

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

    As chamadas de retorno são usadas em todo o lugar no Nó porque o Nó é construído do zero para ser asynchronous em tudo o que faz. Mesmo quando conversando com o sistema de arquivos. É por isso que uma tonelada das APIs do nó interno aceitam funções de retorno de chamada como argumentos, em vez de retornar dados que você pode atribuir a uma variável. Em vez disso, ele invocará sua function de retorno de chamada, transmitindo os dados desejados como argumento. Por exemplo, você pode usar a biblioteca fs do Node para ler um arquivo. O módulo fs expõe duas funções exclusivas da API: readFile e readFileSync .

    A function readFile é assíncrona, enquanto que readFileSync obviamente não é. Você pode ver que eles pretendem usar as chamadas assíncronas sempre que possível, uma vez que as chamam de readFile e readFileSync vez de readFile e readFileAsync . Aqui está um exemplo de usar as duas funções.

    Síncrono:

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

    O código acima bloqueia a execução do encadeamento até que todo o conteúdo do test.txt seja lido na memory e armazenado nos data variables. No nó, isso geralmente é considerado uma prática ruim. No entanto, há momentos em que é útil, por exemplo, ao escrever um pequeno script rápido para fazer algo simples, mas tedioso, e você não se importa muito em economizar cada nanossegundo de tempo possível.

    Assíncrono (com retorno de chamada):

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

    Primeiro, criamos uma function de retorno de chamada que aceita dois argumentos err e data . Um problema com as funções assíncronas é que se torna mais difícil interceptar os erros, de modo que muitas APIs de estilo de retorno de chamada transmitem erros como o primeiro argumento para a function de retorno de chamada. É uma boa prática verificar se err tem um valor antes de fazer qualquer outra coisa. Nesse caso, pare a execução do retorno de chamada e registre o erro.

    Chamadas síncronas têm uma vantagem quando são lançadas exceções, porque você pode simplesmente capturá-las com um bloco try/catch .

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

    Em funções assíncronas, não funciona dessa maneira. A chamada da API retorna imediatamente, então não há nada para pegar com o try/catch . APIs assíncronas apropriadas que usam retornos de chamada sempre capturarão seus próprios erros e, em seguida, passarão esses erros para o retorno de chamada em que você poderá manipulá-lo da maneira que achar melhor.

    Além dos retornos de chamada, há outro estilo popular de API que é comumente usado, chamado de promise. Se você gostaria de ler sobre eles, então você pode ler o post inteiro que escrevi baseado nesta resposta aqui .

    Aqui está um exemplo de copiar arquivo de texto com fs.readFile e 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 esse é um exemplo do uso da function copyFile :

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

    O padrão comum node.js sugere que o primeiro argumento da function de retorno de chamada é um erro. Você deve usar esse padrão porque todos os módulos de stream de controle dependem dele:

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

    Tente este exemplo tão simples quanto você pode ler, apenas copie save newfile.js do node newfile para executar o aplicativo.

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

    estamos criando uma function simples como

     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 }