exemplo simples de callbacks do nodeJs
Qualquer um pode me dar um exemplo simples de callbacks nodeJs, eu já procurei o mesmo em muitos sites, mas não capaz de entendê-lo corretamente, por favor, dê-me um exemplo simples.
getDbFiles(store, function(files){
getCdnFiles(store, function(files){
})
})
Quero fazer algo assim...
5 answers
var myCallback = function(data) {
console.log('got data: '+data);
};
var usingItNow = function(callback) {
callback('get it?');
};
Agora abra o nó ou a consola do navegador e cole as definições acima.
Finalmente usa-o com esta próxima linha:
usingItNow(myCallback);
No que diz respeito às convenções de erros do estilo do nó
O Costa perguntou como seria isto se honrássemos as Convenções de callback de erro de nó.
Nesta convenção, o callback deve esperar receber pelo menos um argumento, o primeiro argumento, como um erro. Opcionalmente teremos um ou mais argumentos, dependendo do contexto. Neste caso, o contexto é o nosso exemplo acima.
Aqui reescrevo o 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 queremos simular um caso de erro, podemos definir usingItNow como este
var usingItNow = function(callback) {
var myError = new Error('My custom error!');
callback(myError, 'get it?'); // I send my error as the first argument.
};
A utilização final é exactamente a mesma que em cima:
usingItNow(myCallback);
A única diferença de comportamento seria dependente da versão de usingItNow
que você definiu: a que alimenta um " valor truthy "(um objeto de erro) para a chamada de resposta para o primeiro argumento, ou aquele que o alimenta nulo para o argumento de erro.
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);
}
Em funções assíncronas, não funciona assim. A chamada da API retorna imediatamente para que não haja nada para pegar com o try/catch
. APIs assíncronos adequados que usam callbacks sempre pegar seus próprios erros e, em seguida, passar esses erros para o callback onde você pode lidar com isso como quiser.
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
}