No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Compra acceso a todo Platzi por 1 a帽o

Antes: $249

Currency
$209/a帽o

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Suscr铆bete

Termina en:

15D
10H
10M
0S

Error First Callbacks

28/31
Recursos

Aportes 44

Preguntas 3

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

Lanzar una excepcion con Throw dentro de un callback asincrono no va a funcionar鈥 Solo nos va a funcionar en n bloque de codigo sincrono

Si el V8 es el coraz贸n de Nodejs, los callbacks son sus venas. 馃挌

Error First Callbacks


Un patr贸n que se sigue siempre en cualquier lenguaje y programa de devs es Error First Callbacks, esto quiere decir que siempre que tengamos un callback el primer par谩metro deber铆a ser el error.

馃槶 Esto se usa por la convenci贸n de que todo puede fallar.

Otro patr贸n t铆pico es tener el callback es tener en el callback como la 煤ltima funci贸n que se pasa. Aunque depende del caso.

function asincrona(callback) {
    setTimeout(() => {
        try {
            let a = 3 + w
            callback(null, a)
        } catch (error) {
            callback(error)
        }
    }, 1000)
}

asincrona((err, dato) => {
    if (err) {
        console.error('Tenemos un error')
        console.error(err)
        return false

        // throw err
    }

    console.log(`Todo ha ido bien, mi dato es ${dato}`)
})

Los Error First Callbacks se utilizan para pasar primero el error y los datos posteriormente. Entonces, puedes verificar el primer argumento, es decir, el objeto de error para ver si algo sali贸 mal y puedes manejarlo. En caso de que no haya ning煤n error, puedes utilizar los argumentos posteriores y seguir adelante.

fs.readFile('/text.txt', function(err, data) {
	if (err) {
		console.log(err);
	} else {
		console.log(data);
	} 
});

esta medio confuso esto, pero creo que es cuesti贸n de ponerlo en pr谩ctica!

los throw no funcionan con callbacks asincronos

驴por qu茅 no seguir el modelo de una promesa resolve/reject?

Siempreee el error es lo primero que se evalua



function asincrona() {
    setTimeout(function () {
        try {
            let a =3+z;
            callback(null,a);

        } catch (error) {
            callback(error);
        }
    },1000);
}

asincrona(function (error,dato) {

    if(error){
        console.error('tenemos un error');
        console.error(error);
        return false;
    }

    console.log('todo ha ido bien',data);

})```

Error First Callback

Con el pensamiento de que todo en alg煤n momento puede fallar, una convenci贸n que se ha generado es poner como primer par谩metro el error en todos los m贸dulos que vaya a generar.

function asyncFunction(callback) {
  setTimeout(() => {
    try {
      let a = 3 + z
      callback(null, a)
    } catch (e) {
      callback(e, null)
    }
  }, 1000)
}

En este momento hay una funci贸n as铆ncrona, que tiene como par谩metro un Callback, y esta generando un error debido a que la variable z no esta definida. Para agarrar el error se puede hacer el Error First Callback.

asyncFunction((err, data) => {
  if (err) {
    console.error('Tenemos un error')
    console.error(err)
    return false
  }
  console.log(`Todo va bien, la data es ${data}`)
})

El primer par谩metro que recibe el Callback es el error para seguir la convenci贸n que se utiliza 煤ltimamente.

Este patr贸n se debe seguir cuando se trabaje con funciones as铆ncronas.

En este caso lanzar un error mediante throw no va a funcionar debido a que se esta manejando funciones as铆ncronas y est谩s son manejadas por el Callback Queue y el Event Loop.

Links de inter茅s

Callbacks

Callbacks 2

try catch no es util para las funciones asincronas porque no captura el error, ya que esta en otro hilo

Ey como estan? retoque un poquitin el codigo para que sea mas entendible como funciona los callbacks en este caso鈥

function asincrona(callback) {
    setTimeout(function() {
        try{
        let dato = 3 + z;
        callback(null,dato);
        } catch(err) {
            callback(err);
        }
    }, 1000);
}
//esta seria la funcion callback
asincrona(function (err, dato) {
    if(err) {
        console.error(err.message);
        return false;
    }
    console.log("todo ha ido bien " + dato);
})

Con esto se puede ver como el parametro de 鈥渁sincrona鈥, empieza a trabajar como llamada a una funcion nueva. Esta genera que segun como funcione el codigo, si no genera error enonces llamo a la funcion callback y le paso como parametro dato, pero si falla entonces llamo a callback y le paso como parametro err.

Los Error First Callbacks se utilizan para pasar primero el error y los datos posteriormente. Entonces, puedes verificar el primer argumento, es decir, el objeto de error para ver si algo sali贸 mal y puedes manejarlo.

function asincrona(callback) {
    
    setTimeout(function() {
        try {
            let a = 3 + z;
            callback(null, a)
        } catch (error) {
            callback(error);
        }
    }, 1000)
}

asincrona(function(err, dato) {
    if (err) {
        console.error('Tenemos un error');
        console.error(err);

        //throw err;  // No va a funcionar cuando es asincrona
        return false;
    }

    console.log('Todo ha ido bien, el dato es', dato)
})

Error First Callback. Cuando utilizamos un callback, debemos tener en cuenta que todo puede fallar, por lo que el primer par谩metro que definamos debe ser el de error.

Hola! Si alguien tiene dudas de c贸mo lidiar con errores en Js y sabe un poco de english jaja, mire este articulo de como lidiar con errores asyncronos

Pregunta de examen:
En un callback, 驴cu谩l deber铆a ser el primer par谩metro?

/* Siempre que tengamos un callback el primer parametro deberia ser el error por que es una convension pensando en que todo puede fallar y debemos ser capaces de controlarlo */

/* throw error para funciones asincronas no va a funcionar */

function asincrona(callback) {
    setTimeout(function() {
        try {
            let a = 3 + z;
            callback(null, a);
        } catch (e) {
            callback(e);
        }
    }, 1000)
}

asincrona(function (err, dato) {
    if (err) {
        console.error('Tenemos un error');
        console.error(err);
        return false;
    }

    console.log('todo ha ido bien, mi data es', dato);
})

馃槂 El Error First Callbacks: Se utilizan para pasar primero el error y los datos posteriormente. Podemos verificar el primer argumento. El objeto de error para ver si algo sali贸 mal para poder manejarlo. En caso de que no haya ning煤n error, podemos utilizar los argumentos y seguir adelante.

function asincrona(callBack) {
    setTimeout(function() {
        try {
            let a = 3 + z;
            callBack(null, a);
        } catch (e) {
            callBack(e);
        }
    }, 1000);
}

asincrona(function(err, dato) {
    if (err) {
        console.error("Tenemos un error");
        console.error(err);
        // Para funciones sincronas --> throw err
        return false;
    }
    console.log("Todo ha ido bien, mi data es", dato);
});

Error First Callback
Un patr贸n, siempre que tengamos un callback el primer par谩metro deber铆a ser el error.

Para funciones s铆ncronas
throw err;

/* Funci贸n para m铆 callback  */
function mycb(err, dato){
    if (err){
        /* Capturar el error */
        console.error("Ha ocurrido un error")
        console.error(err)
        return false; /* Buena pr谩ctica para detener la ejecuci贸n de la funci贸n */
    } else{
        console.log("Todo bien" + dato);
    }
}
/* Funci贸n principal as铆ncrona */
function setError(callback) {
    setTimeout(() => {
        try {
            let a = 3 + Z;
            /* mycb(null, a) */
            callback(null, a);
        } catch (e) {
            /* mycb(e, null) */
            callback(e);
        }
    }, 3000);
}
/* Llamado */
setError(mycb); 

GO se parece mucho a JS en el sentido de err first.


function Asyncro(callback){
    setTimeout(function() {
        try{
            let a = 3 + Zesz;
            callback(null, a);
        }   catch(e){
            callback(e);
        }
    })
}

Asyncro(function(err, date) {
if(err){
        console.error('we have a error');
        console.error(err)
        // throw err; //No funciona en async
    }
})

No sabia que mandar primero el error era una convenci贸n, simplemente cre铆 que era una buena practica. Aunque considero que lo realmente importante es siempre contemplar que algo pude fallar. El uso del Try / Catch es escencial

/*
 ErrorFirst
*/

function asincrona(callback){
  setTimeout(() => {
    try {
      let a = 3 + z;
      callback(null, a);
    } catch(error) {
      callback(error);
    }
  }, 1000);
}

/*
  Con errorFirst, no funciona el throw, este es mejor
  usarlo en funciones sincronas
*/

asincrona(function(error, dato){
  if(error) {
    console.error('Tenemos un error', error.message);
    // throw error;
    return false;
  };

  console.log('Todo ha ido bien', dato);
})```

interesante,. el manejo de errores

function asincrona(callback) {
    setTimeout(() => {
        try {
            let a = 3 + z;
            callback(null, a);
        } catch (error) {
            callback(error);
        }
    }, 1000);
};


 asincrona( (error, dato) => {
     if (error) {
          console.error('tenermos error');
          console.error(error);
          return false;
          //no funciona con funciones asicronas
         //throw error;
     }

     console.log('todo bien', dato);
 })

Aqu铆 el c贸digo con apuntes.

function asincrona(callback) {
	setTimeout(function () {
		try {
			let a = 3 + z;
			callback(null, a);
		} catch (e) {
			callback(e);
		}
	}, 1000);
}
// !PATRON ERRORFIST,CALLBACK ES EL QUE TENEMOS QUE SEGUIR SIEMPRE QUE TRABAJEMOS CON FUNCIONES ASINCRONAS Y CALLBACKS

asincrona(function (err, data) {
	if (err) {
		console.error('Tenemos un error');
		console.error(err);
		return false;
		//throw err // !EL PATRON THROW VA A VENIR MUY BIEN PARA FUNCIONES SINCRONAS PERO NO VA A FUNCIONAR EN ASINCRONA
	}

	console.log('Todo ha ido bien mi data es', data);
});

Tambien podemos usar el operador ternario de la siguiente manera para que quede mas bonito y legible:

fs.readFile('/text.txt', (err, data) => {
  (err) ? console.error('Hubo un error', err.message) : console.log('Todo ok, tu info es:', data)
}
function asincrona() {
    setTimeout(function () {
        try {
            let a =3+z;
            callback(null,a);

        } catch (error) {
            callback(error);
        }
    },1000);
}

asincrona(function (error,dato) {

    if(error){
        console.error('tenemos un error');
        console.error(error);
        return false;
    }

    console.log('todo ha ido bien',data);

})

**veo que la mayoria omite el hecho de leer los erros de consola detenidamente, hay un error del tipo referenceError que se debe a que en la suma no se ha declarado el valor de 鈥渮鈥 **

z is not defined --> ojo a esta observacion

No me quedo muy claro 鈥淓rror First Callbacks鈥. Alg煤n aporte al respecto, please

Aqu铆 hay un peque帽o error, el hecho de que no funcione el throw error no es porque la funci贸n sea asincrona, sino porque estamos usando callbacks y en el momento en que se lanza el throw error, el contexto que le llam贸 :

...
} catch (error) {
        callback(error);
}
....

Ya no existe, hay que recordar que los errores se elevan, por lo que el error sucedi贸 dentro de la funcion 鈥渃allback鈥 que en este caso es la funcion llamada 鈥渁sincrona鈥 , por ejemplo, si ejecutan esto van a ver como es que el error se eleva y si que se puede seguir manejando :

function asincrona(callback) {
    
    setTimeout(function() {
        try {
            let a = 3 + z;
            callback(null, a)
        } catch (error) {
            try{

                callback(error);
            }catch(e){
                console.log('aqui va a venir despues del throw err')
            }
        }
    }, 1000)
}

Por todo esto, el que no funcione el throw error no tiene nada que ver con que sea asincrona, sino con que estemos usando callbacks, las promesas tamb铆en son as铆ncronas y si las manejamos bien podemos usar throws sin problemas en ambos casos.

Error-First Callback en Node.js es una funci贸n que devuelve un objeto de error o cualquier dato exitoso devuelto por la funci贸n.

Todo puede fallar, importante tenerlo siempre en cuenta.

super 馃槂

Wow 馃く

Very useful!

Bastante util!

Cool

en lo personal si existe dicho metodo a sincrono, con promesas prefiero usarlo de esa manera o adaptarlo ya que callbacks es una forma de programar algo arcaica, aunque no quiere decir que no los use, pero que ellos sean el core de lo que hago no es mi objetivo