javascript - what - nodeJs callbacks simple example

node js callback pattern

Question

¿Puede alguien darme un ejemplo simple de devoluciones de llamada de nodeJs, ya he buscado lo mismo en muchos sitios web pero no puedo entenderlo correctamente, por favor dame un ejemplo simple.

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

Quiero hacer algo como eso...

Answer 1

Aquí hay un ejemplo de copia de archivo de texto con fs.readFile y 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);
  });
};

Y ese es un ejemplo del uso de la función 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!'');
  }
});

El patrón node.js común sugiere que el primer argumento de la función de devolución de llamada es un error. Debe usar este patrón porque todos los módulos de flujo de control dependen de él:

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

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

Answer 2

Pruebe este ejemplo tan simple como pueda leer, solo copie save newfile.js do node newfile para ejecutar la aplicación.

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

Answer 3

Una función de devolución de llamada es simplemente una función que pasa a otra función para que la función pueda llamarla más tarde. Esto se ve comúnmente en API síncronas; la llamada a API se devuelve inmediatamente porque es asíncrona, por lo que le transfiere una función a la que la API puede llamar cuando finaliza su tarea asíncrona.

El ejemplo más simple que puedo pensar en JavaScript es la función setTimeout() . Es una función global que acepta dos argumentos. El primer argumento es la función de devolución de llamada y el segundo argumento es un retraso en milisegundos. La función está diseñada para esperar la cantidad de tiempo adecuada y luego invocar su función de devolución de llamada.

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

Es posible que haya visto el código anterior pero no se dio cuenta de que la función que estaba pasando se llamaba función de devolución de llamada. Podríamos reescribir el código anterior para hacerlo más obvio.

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

Las rellamadas se usan por todos lados en Node porque Node está construido desde cero para ser asincrónico en todo lo que hace. Incluso cuando hablas con el sistema de archivos. Es por eso que una tonelada de las API internas de nodo aceptan funciones de devolución de llamada como argumentos en lugar de devolver datos que puede asignar a una variable. En su lugar, invocará su función de devolución de llamada, pasando los datos que desea como argumento. Por ejemplo, podría usar la biblioteca fs de Node para leer un archivo. El módulo fs expone dos funciones API únicas: readFile y readFileSync .

La función readFile es asíncrona, mientras que readFileSync obviamente no lo es. Puede ver que tienen la intención de utilizar las llamadas asincrónicas siempre que sea posible, ya que los llamaron readFile y readFileSync lugar de readFile y readFileAsync . Aquí hay un ejemplo del uso de ambas funciones.

Sincrónico:

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

El código anterior bloquea la ejecución de la test.txt hasta que todos los contenidos de test.txt se leen en la memoria y se almacenan en los data variables. En el nodo, esto se considera una mala práctica. Sin embargo, hay momentos en los que es útil, como cuando se escribe un pequeño guión rápido para hacer algo simple pero tedioso y no le importa mucho ahorrar cada nanosegundo de tiempo que pueda.

Asincrónico (con devolución de llamada):

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

Primero creamos una función de devolución de llamada que acepta dos argumentos err y data . Un problema con las funciones asíncronas es que resulta más difícil atrapar errores, por lo que muchas API de tipo devolución de llamada pasan errores como el primer argumento de la función de devolución de llamada. Es una buena práctica verificar si err tiene un valor antes de hacer cualquier otra cosa. De ser así, detenga la ejecución de la devolución de llamada y registre el error.

Las llamadas sincrónicas tienen una ventaja cuando hay excepciones lanzadas porque simplemente puede atraparlas con un bloque try/catch .

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

En las funciones asincrónicas, no funciona de esa manera. La llamada API regresa inmediatamente, por lo que no hay nada que atrapar con la try/catch . Las API asíncronas adecuadas que utilizan devoluciones de llamadas siempre detectarán sus propios errores y luego pasarán esos errores a la devolución de llamada, donde puede manejarlos como mejor le parezca.

Además de las devoluciones de llamada, hay otro estilo popular de API que se usa comúnmente llamado promesa. Si desea leer sobre ellos, puede leer la publicación completa del blog que escribí basada en esta respuesta here .

Answer 4

estamos creando una función simple 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
}

Answer 5

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

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

Ahora abra el nodo o la consola del navegador y pegue las definiciones anteriores.

Finalmente utilícelo con esta próxima línea:

usingItNow(myCallback);

Con respecto a las convenciones de error de estilo de nodo

Costa preguntó cómo se vería si respetáramos las convenciones de devolución de error de nodo.

En esta convención, la devolución de llamada debe esperar recibir al menos un argumento, el primer argumento, como un error. Opcionalmente tendremos uno o más argumentos adicionales, dependiendo del contexto. En este caso, el contexto es nuestro ejemplo anterior.

Aquí reescribo nuestro ejemplo en esta convención.

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

Si queremos simular un caso de error, 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.
};

El uso final es exactamente el mismo que el anterior:

usingItNow(myCallback);

La única diferencia en el comportamiento dependerá de la versión de usingItNow que haya definido: la que alimenta un "valor de verdad" (un objeto Error) a la devolución de llamada para el primer argumento, o la que lo alimenta nulo para el error argumento.