exemplo simples de callbacks de nodeJs

qualquer um pode me dar um exemplo simples de callbacks do nodeJs, eu já pesquisei o mesmo em muitos sites, mas não consigo entendê-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 console do navegador e cole as definições acima.

Finalmente, use-o com a próxima linha:

usingItNow(myCallback);

Com relação às convenções de erro de estilo de nó

Costa perguntou como seria se honrássemos as convenções de callback de erro de nó.

Nessa 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. Nesse caso, o contexto é nosso exemplo acima.

Aqui, 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 dependente de qual versão de usingItNowvocê definiu: aquela que alimenta um "valor verdadeiro" (um objeto Error) para o retorno de chamada para o primeiro argumento, ou aquela que o alimenta nulo para o argumento de erro .

Uma função de retorno de chamada é simplesmente uma função que você passa para outra função para que essa função 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 função para ela que a API pode chamar quando terminar de executar sua tarefa assíncrona.

O exemplo mais simples que consigo pensar em JavaScript é a setTimeout()função. É uma função global que aceita dois argumentos. O primeiro argumento é a função de retorno de chamada e o segundo argumento é um atraso em milissegundos. A função foi projetada para aguardar o período de tempo apropriado e, em seguida, invocar sua função 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 função que estava passando era chamada de função de retorno de chamada. Poderíamos reescrever o código acima para torná-lo mais óbvio.

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

Callbacks são usados ​​em todo lugar no Node porque o Node é construído desde o início para ser assíncrono em tudo o que faz. Mesmo ao falar com o sistema de arquivos. É por isso que muitas APIs de Nó internas 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 função de retorno de chamada, passando os dados que você deseja como argumento. Por exemplo, você pode usar a fsbiblioteca do Node para ler um arquivo. O fsmódulo expõe duas funções de API exclusivas: readFilee readFileSync.

A readFilefunção é assíncrona, enquanto readFileSyncobviamente não é. Você pode ver que eles pretendem que você use as chamadas assíncronas sempre que possível, uma vez que as chamaram readFilee em readFileSyncvez de readFilee readFileAsync. Aqui está um exemplo do uso de ambas as funções.

Síncrono:

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

O código acima bloqueia a execução do thread até que todo o conteúdo test.txtseja lido na memória e armazenado na variável data. No nó, isso é normalmente considerado uma prática ruim. Porém, há momentos em que é útil, como 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 que puder.

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 função de retorno de chamada que aceita dois argumentos erre data. Um problema com funções assíncronas é que se torna mais difícil detectar erros, portanto, muitas APIs de estilo de retorno de chamada passam os erros como o primeiro argumento para a função de retorno de chamada. É uma prática recomendada verificar se errtem um valor antes de fazer qualquer outra coisa. Em caso afirmativo, pare a execução do retorno de chamada e registre o erro.

As chamadas síncronas têm uma vantagem quando há exceções lançadas porque você pode simplesmente capturá-las com um try/catchbloco.

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

Em funções assíncronas, não funciona assim. A chamada API retorna imediatamente assim não há nada a captura com o try/catch. APIs assíncronas adequadas que usam retornos de chamada sempre capturarão seus próprios erros e, em seguida, passarão esses erros para o retorno de chamada, onde você pode manipulá-los conforme achar necessário.

Além dos retornos de chamada, existe outro estilo popular de API comumente usado, chamado de promessa. Se você gostaria de ler sobre eles, você pode ler todo o post do blog que escrevi com base nesta resposta aqui .

Aqui está um exemplo de cópia de arquivo de texto com 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 este é um exemplo de uso de copyFilefunção:

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 função de retorno de chamada é um erro. Você deve usar este padrão porque todos os módulos de fluxo de controle dependem dele:

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

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

Experimente este exemplo o mais simples possível, basta copiar 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 função 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
}

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' é um módulo de nó que ajuda você a ler o arquivo. A função de retorno de chamada garantirá que seu arquivo denominado 'input.txt' seja completamente lido antes de ser executado. A função fs.stat () é obter informações do arquivo, como tamanho do arquivo, data de criação e data de modificação.

A callbacké uma função passada como parâmetro para a Higher Order Function( wikipedia ). Uma implementação simples de um retorno de chamada seria:

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

Para chamar a função, basta passar outra função como argumento para a função definida.

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

Esta postagem do blog tem um bom artigo:

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