No tienes acceso a esta clase

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

Error First Callbacks

28/31
Recursos

Aportes 40

Preguntas 3

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Reg铆strate o inicia sesi贸n para participar.

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. 馃挌

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

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

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

})```

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

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

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

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

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

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

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.

/*
 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

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

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