Tu primera experiencia con Node.js

1

¿Dónde aprender backend con Node.js actualizado?

2

Todo lo que aprenderás sobre backend con Node.js

3

¿Qué es Node.js?

4

¿Qué es Node.js y para qué sirve?

5

Diferencias entre Node.js y JavaScript

6

Resumen: Diferencias Nodejs y Javascript

7

Instalación de Node.js

8

Arquitectura orientada a eventos

9

Node.js para la web

Manejo y uso de Streams con Node.js

10

Introducción a streams

11

Readable y Writable streams

12

Duplex y Transforms streams

Uso de utilidades de Node.js

13

Sistema operativo y sistema de archivos

14

Administrar directorios y archivos

15

Consola, utilidades y debugging

16

Clusters y procesos hijos

Crea tu primer proyecto en Express.js

17

¿Qué es Express.js y para qué sirve?

18

Creando tu primer servidor con Express.js

19

Request y Response Objects

Aprende a crear un API con REST

20

Anatomía de una API Restful

21

Estructura de una película con Moockaru

22

Implementando un CRUD en Express.js

23

Métodos idempotentes del CRUD

24

Implementando una capa de servicios

Cómo conectarse con librerías externas en Express.js

25

Creación de una BD en MongoAtlas

26

Conexión a MongoAtlas una instancia de MongoDB

27

Conexión con Robot3T y MongoDB Compass a una BD

28

Implementación de las acciones de MongoDB

29

Conexión de nuestros servicios con MongoDB

Conoce como funcionan los Middleware en Express.js

30

¿Qué es un middleware? Capa de manejo de errores usando un middleware

31

Manejo de errores asíncronos y síncronos en Express

32

Capa de validación de datos usando un middleware

33

¿Qué es Joi y Boom?

34

Implementando Boom

35

Implementando Joi

36

Probar la validación de nuestros endpoints

37

Middlewares populares en Express.js

Implementa tests en Node.js

38

Creación de tests para nuestros endpoints

39

Creación de tests para nuestros servicios

40

Creación de tests para nuestras utilidades

41

Agregando un comando para coverage

42

Debugging e inspect

Despliega tu primera aplicación en Express.js

43

Considerando las mejores prácticas para el despliegue

44

Variables de entorno, CORS y HTTPS

45

¿Cómo implementar una capa de manejo de caché?

46

¿Cómo contener tu aplicación en Docker?

47

Despliegue en Now

Conclusiones

48

¿Qué aprendiste en este curso?

Manejo de errores asíncronos y síncronos en Express

31/48

Lectura

El manejo de errores en Express es el proceso de capturar un error de manera asíncrona como síncrona . Por defecto Express viene con un manejador de errores por defecto, así que no es necesario escribir uno para empezar a usarlo.

Los errores que ocurren de manera síncrona dentro un manejador de rutas o un middleware no requieren trabajo extra. Si un código síncrono lanza un error Express automáticamente capturará el error. Por ejemplo:

app.get("/", function(req, res) {
  throw new Error("BROKEN"); // Express capturara este error por sí solo.
});

Para errores que se retornan desde funciones asíncronas invocadas desde un manejador de ruta o un middleware, es necesario pasar el error como argumento a la función next(), de esta manera Express capturará el error y lo procesará. Por ejemplo:

app.get("/", function(req, res, next) {
  fs.readFile("/file-does-not-exist", function(err, data) {
    if (err) {
      next(err); // Se debe pasar el error a Express.
    } else {
      res.send(data);
    }
  });
});

Es responsabilidad de nosotros capturar errores que puedan ocurrir en código asíncrono invocado desde un manejador de ruta o middleware para que Express lo procese. Por ejemplo:

app.get("/", function(req, res, next) {
  setTimeout(function() {
    try {
      throw new Error("BROKEN");
    } catch (err) {
      next(err);
    }
  }, 100);
});

El ejemplo de arriba usa un bloque try...catch para capturar los errores en el código asíncrono y pasarlo a Express. Si el bloque try...catch fuese omitido, Express no podría capturar el error debido a que no es parte de un manejador síncrono de código.

Cuando se usan funciones que retornan promesas, puedes simplemente proveer la funcionalidad next al final del manejador catch de la promesa y Express automáticamente capturará el error. Por ejemplo:

app.get("/", function(req, res, next) {
  Promise.resolve()
    .then(function() {
      throw new Error("BROKEN");
    })
    .catch(next); // Errores serán pasados a Express.
});

Aportes 30

Preguntas 0

Ordenar por:

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

En la documentación oficial explican un poco mas sobre el tema. Manejo de Errores Express

Si se fijan, siempre que se manejan errores asíncronos con async/await, tenemos la misma estructura.

try {
	// operaciones asíncronas
} catch(err) {
	next(err)
}

y esta sintaxis repetitiva se puede empezar a acumular en nuestras rutas y middlewares.
Les recomiendo el paquete express-async-errors. Con este pueden eliminar completamente los bloques try/catch.
El paquete se usa importandolo index.js o en el archivo principal del servidor.

require('express-async-errors')

Como ejemplo, hasta este punto del curso, la ruta para el endpoint GET api/movies/ es esta

router.get('/', async (req, res, next) => {
    const { tags } = req.query;
    try {
      const movies = await movieService.getMovies({ tags });
      res.status(200).json({
        data: movies,
        message: 'movies listed',
      });
    } catch (err) {
      next(err);
    }
  }
)

y pasaria a escribirse simplemente así:

router.get('/', async (req, res, next) => {
    const { tags } = req.query;
    const movies = await movieService.getMovies({ tags });
    res.status(200).json({
      data: movies,
      message: 'movies listed',
    });
  }
)

En caso de que ocurra un error en la función async, el paquete se encarga de llamar automáticamente al middleware de error que implementamos.

fue uns gran explicacion muy detallada de como se deben capturar los erros para que puedan ser procesados por los middleware de manejo de errores en Express

Ya había usado next() pero no entendía cómo era su función. Con esta lectura me queda un poco más claro. Checare documentación para entenderlo al 100%

Gracias!

le entendi :3

Buena aclaración

Esta explicación estuvo bien.

Express maneja los errores que ocurren se manera síncrona, pero es responsabilidad de nosotros manejar los errores asíncronos.

Esta lectura, me ayudo a comprender el manejo de errores en Express.

Muy muy muy interesante.

Genial

Interesante lectura. Gracias!!

Buena explicación!

Estupenda explicación lo tendré en cuenta cuando esté desarrollando los métodos para manejar los errores de funciones síncronas y asíncronas.

muy buena explicacion referente a next… no sabia a ciencia cierta cual era su funcionalidad en si… pero ahora entiendo, y mucho mejor con esto de los manejadores de errores…

Esta fue una buena explicación… Express es muy “inteligente en estos casos”

Si se invoca

next('mensaje del error') 

en lugar de

throw new Error('mensaje del error')

¿Tiene el mismo efecto, o es obligatorio declararlo así?

Uno de los temas que mas me cuesta a la hora de aprender un tema es el manejo de errores pero el profesor lo esta explicando muy bien hasta el momento

Esta super, vamo’ a ver 😃

Para errores que se retornan desde funciones asíncronas invocadas desde un manejador de ruta o un middleware, es necesario pasar el error como argumento a la función next().

Bien, me queda claro

en código asíncrono tenemos que siempre utilizar el try-catch

next es un callback opcional que usa express para manejar errores y el encadenamiento de middlewares.

siempre debe ir el bloque try-catch

Gracias

Los middlewares son geniales 😄 !!

WoW algo nuevo que aprender 😃

Vamos!!

router.get('/', async (req, res, next) => {
    const { tags } = req.query || {}
    try {
      const movies = await moviesService.getMovies({ tags })
      throw new Error('Unespected Error');
      res.status(200).json({
        data: movies,
        message: 'movies listed'
      })
    } catch (error) {
      next(error) //esto es lo que llama al middleware
    }
  })