exemplo simples de callbacks do nodeJs

Uma função de callback é simplesmente uma função que você passa para outra função para que essa função possa chamá-la em um momento posterior. Isto é comumente visto em assíncrono APIs; A chamada da API retorna imediatamente porque é assíncrono, então você passa uma função para ela que a API pode chamar quando estiver feito executar sua tarefa assíncrona.

O exemplo mais simples que consigo pensar em JavaScript é a função setTimeout(). É uma função global que aceita dois argumentos. O primeiro argumento é a função de callback e o segundo argumento é um atraso em milisegundos. A função é projetada para esperar a quantidade apropriada de tempo, em seguida, invocar a sua função de callback.

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

Você pode ter visto o código acima antes, mas apenas não percebeu que a função que você estava passando era chamada de função de callback. 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 o lugar no nó porque o nó é construído a partir do solo até ser assíncrona em tudo o que faz. Mesmo ao falar com o sistema de arquivos. É por isso que uma tonelada da APIs do nó interno aceita funções de callback como argumentos ao invés de retornar dados que você pode atribuir a uma variável. Em vez disso, irá invocar a sua função de callback, passando os dados que queria como argumento. Por exemplo, você pode usar a biblioteca do Node fs para ler um arquivo. O Módulo fs expõe duas funções API únicas: readFile e readFileSync.

A função readFile é assíncrona enquanto readFileSync obviamente não é. Você pode ver que eles pretendem que você use as chamadas async sempre que possível, uma vez que eles os chamaram readFile e readFileSync em vez de readFile e readFileAsync. Aqui está um exemplo de usar ambas as funções.

Síncrono:

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

O código acima bloqueia a execução do tópico até que todo o conteúdo de test.txt seja lido na memória e armazenado na variável data. No nó isso é tipicamente considerado uma má prática. Há momentos em que é útil, como quando escrever um script rápido para fazer algo simples, mas tedioso e você não se importa muito em Salvar cada nanossegundo de tempo que você pode.

Assíncrono (com callback):

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 callback que aceita dois argumentos err e data. Um problema com as funções assíncronas é que se torna mais difícil de encurralar erros de modo que um monte de APIs estilo callback passar erros como o primeiro argumento para a função callback. É a melhor prática verificar se err tem um valor antes de fazer qualquer outra coisa. Se assim for, pare a execução do callback e registre o erro.

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

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

Além de callbacks, no entanto, há um outro estilo popular de API que é comumente usado chamado de promessa. Se você gostaria de ler sobre eles, então você pode ler todo o post que eu escrevi com base nesta resposta aqui.

Aqui está um exemplo de copiar o ficheiro 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 este é um exemplo de usar copyFile funçã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!');
  }
});

Nó comum.o padrão js sugere que o primeiro argumento da função callback é 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

Tente este exemplo tão simples como pode ler, basta copiar gravar o ficheiro Novo.js do node newfile para executar a aplicação.

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 a criar 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
}