No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Error First Callbacks

28/31
Recursos

Aportes 49

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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

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

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

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 “asincrona”, 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?

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

/* 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 ASINCRONÍA
	}

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

z is not defined --> ojo a esta observacion

No me quedo muy claro “Error First Callbacks”. Algún aporte al respecto, please

# **✨🦄 Esta clase me pareció muy interesante así que voy a dejar mis apuntes :D** # **Error First Callbacks** El concepto de **Error-First Callbacks** en node es una convención utilizada en el manejo de errores en funciones asíncronas. La idea principal es que **<u>el primer argumento de cualquier callback debe ser reservado para el error</u>**. Esto sigue el principio de que ***"todo en JavaScript puede fallar".*** **Callback con formato estándar**: * El primer parámetro del callback será el error (`err`), y si no hay errores, se pasa `null`. * Los siguientes parámetros son los datos resultantes de la operación asíncrona. **Ejemplo:** ![](https://static.platzi.com/media/user_upload/image-e6b3c704-81ff-4375-b1f7-a3ffa0031cc2.jpg) En este código, como ya se mencionó en secciones anteriores, cada función asíncrona debe manejar dentro de si misma sus posibles errores/excepciones debido a que estos solo ocurrirán en el hilo donde se está ejecutando la función asíncrona. Cuando se manda a llamar a la función asíncrona, el primer parámetro que se establece en la definición del callback es el `error` , así cuando utilicemos el callback en la función asíncrona, envíamos como único parámetro (pueden ser más dependiendo del caso) al error. Permitiendo así el manejo del error en la definición del callback. **Callbacks vs** `Throw`: En funciones síncronas, se puede usar `throw` para lanzar errores, pero en las funciones asíncronas, lanzar un error con `throw` no funcionará como se espera, ya que el error no será capturado por el contexto de la función asíncrona. Por ello, se utiliza el enfoque de callback con el primer argumento como error.
Aqui dejo un ejemplo de como manejar los errores con la convención Error First usando Promesas. Tambien se podria usar Try Catch en lugar del then() catch() pero ya es cuestion de gustos ![](https://static.platzi.com/media/user_upload/image-3722aa26-d11a-4c90-9ef6-7b366fdddad9.jpg)
gracias a platzi por los dias gratiis
Los "Error First Callbacks" son un patrón comúnmente utilizado en Node.js para manejar devoluciones de llamada asincrónicas. Este patrón se basa en la convención de que el primer argumento pasado a una devolución de llamada será un objeto de error, si ocurre un error, y el segundo argumento será el resultado de la operación asincrónica.

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 “callback” que en este caso es la funcion llamada “asincrona” , 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

**ERROR FIRST CALLBACK** *El **patrón*** 'error-first callback' *es una **convención ampliamente utilizada** en* **Node.js** *y **otros** **lenguajes** de **programación** para **manejar** **asincronía** y **errores** en las **funciones**. En este **patrón**, el **primer argumento** de los **callbacks** **siempre** está **reservado** para un **posible** **error**, **mientras** que los **argumentos** **siguientes** se **utilizan** para los **resultados** **exitosos** de la **operación**. **Si** **no** se **produce ningún error**, el **primer** **argumento** se pasa como **null** o **undefined**. Este **enfoque estandariza** la **forma** en que se **manejan** los **errores** y **simplifica** la **lógica** de **control** de **flujo**, permitiendo a los **desarrolladores** **comprobar** de manera **consistente** la **existencia** de **errores** **antes** de **procesar** los **resultados**. Por ejemplo, una **función** **asíncrona** **típica** que **sigue** este **patrón** puede **tener** una **firma** como* **function(err, data)***, **donde*** **err** ***representa** un **posible** **error** y* **data** ***contiene** los **resultados** de la **operación** **si no** hay **errores**. Este **patrón** es **fundamental** para **escribir** **código** **asíncrono** **limpio** y **manejable** en* **Node.js***.*