El conocimiento es el nuevo dinero.
Aprender es la nueva manera en la que inviertes
Acceso Cursos

De Promesas a Observables: Elevando la programación asíncrona en NestJS

NestJS, con su arquitectura robusta y su compatibilidad con TypeScript, se ha convertido en una opción popular para crear aplicaciones del lado del servidor escalables y mantenibles.

· 4 min de lectura
De Promesas a Observables: Elevando la programación asíncrona en NestJS


Una de las características clave de NestJS es su compatibilidad con paradigmas de programación asíncrona, en particular la transición de promesas a observables. En este artículo, profundizaremos en el concepto de promesas y observables en NestJS, exploraremos por qué los observables son ventajosos y proporcionaremos ejemplos completos que cubren varios escenarios.

Promesas y observables


Promesas 🙏🏼


Las promesas son una parte fundamental del modelo de programación asíncrona de JavaScript. Representan un proxy de un valor que estará disponible o de un error que se producirá.

Las promesas ofrecen una alternativa más limpia a los enfoques basados en callbacks, permitiendo un código más legible y fácil de mantener.
CPU
1 vCPU
MEMORIA
1 GB
ALMACENAMIENTO
10 GB
TRANSFERENCIA
1 TB
PRECIO
$ 4 mes
Para obtener el servidor GRATIS debes de escribir el cupon "LEIFER"

En NestJS, las promesas se utilizan ampliamente para manejar operaciones asíncronas como consultas a bases de datos, peticiones HTTP y E/S de archivos. He aquí un ejemplo básico del uso de promesas en un servicio NestJS:

@Injectable()
export class UserService {
  async findAll(): Promise<User[]> {
    return await this.userModel.find().exec();
  }
}

Observables 👀


Los observables, por otro lado, son una abstracción más potente para manejar flujos de datos asíncronos. Permiten manejar múltiples valores a lo largo del tiempo, lo que los hace idóneos para situaciones como la gestión de eventos, el almacenamiento de datos en caché y las actualizaciones en tiempo real.

NestJS aprovecha los observables a través de bibliotecas como RxJS, permitiendo paradigmas de programación reactiva dentro de su marco. A continuación se explica cómo utilizar observables en un servicio NestJS:

import { Injectable } from '@nestjs/common';
import { Observable } from 'rxjs';
import { User } from './user.interface';

@Injectable()
export class UserService {
  findAll(): Observable<User[]> {
    return from(this.userModel.find().exec());
  }
}

Ventajas de los Observables en NestJS


Procesamiento asíncrono de flujos


Los observables sobresalen en el manejo de flujos de datos de forma asíncrona. En escenarios donde los datos llegan de forma incremental o en tiempo real, los observables ofrecen una forma más natural y eficiente de procesar estos datos en comparación con las promesas.

Componibilidad y gestión de errores


Los observables proporcionan potentes operadores que permiten componer fácilmente operaciones asíncronas.

Operadores como map, filter y mergeMap permiten a los desarrolladores manipular flujos de datos con facilidad.

Además, los observables ofrecen sólidos mecanismos de gestión de errores, lo que permite que los errores se propaguen con gracia a través del flujo.

Observables fríos y calientes


Hay dos tipos de observables: fríos y calientes. Los observables fríos comienzan a producir valores cuando un consumidor se suscribe a ellos, lo que los hace adecuados para escenarios en los que cada consumidor necesita su propio flujo independiente de datos.

Los observables calientes, por otro lado, emiten valores independientemente de si hay algún suscriptor, lo que los hace ideales para escenarios como el manejo de eventos.

Uso de Observables en NestJS: Ejemplos


Recuperación básica de datos


Empecemos con un ejemplo básico de uso de observables para recuperar datos de una base de datos en un controlador NestJS:

import { Controller, Get } from '@nestjs/common';
import { Observable } from 'rxjs';
import { User } from './user.interface';
import { UserService } from './user.service';

@Controller('users')
export class UserController {
  constructor(private readonly userService: UserService) {}
  @Get()
  findAll(): Observable<User[]> {
    return this.userService.findAll();
  }
}

Actualizaciones en tiempo real con WebSockets


Ahora, vamos a explorar un escenario más avanzado en el que utilizamos observables para empujar actualizaciones en tiempo real a los clientes utilizando WebSockets:

import { WebSocketGateway, WebSocketServer, SubscribeMessage } from '@nestjs/websockets';
import { Server } from 'socket.io';
import { Observable } from 'rxjs';
import { User } from './user.interface';
import { UserService } from './user.service';

@WebSocketGateway()
export class UserGateway {
  constructor(private readonly userService: UserService) {}
  @WebSocketServer() server: Server;
  @SubscribeMessage('getUsers')
  getUsers(): Observable<User[]> {
    return this.userService.findAll();
  }
}

Sección FAQ


P: ¿Cuándo debo utilizar promesas en lugar de observables en NestJS?


R: Las promesas son adecuadas para operaciones asíncronas simples que implican un solo valor o un evento de una sola vez. Si está tratando con flujos de datos o necesita una composición más avanzada y gestión de errores, los observables son una mejor opción.

P: ¿Son los observables más difíciles de entender que las promesas?


R: Aunque los observables tienen una curva de aprendizaje más pronunciada que las promesas, ofrecen más potencia expresiva y flexibilidad, especialmente en escenarios asíncronos complejos.

P: ¿Puedo mezclar promesas y observables en NestJS?


R: Sí, NestJS proporciona interoperabilidad sin fisuras entre promesas y observables, lo que le permite elegir la mejor herramienta para el trabajo en cualquier escenario dado.

Conclusión


En conclusión, NestJS ofrece un sólido soporte tanto para promesas como para observables, permitiendo a los desarrolladores elegir el paradigma de programación asíncrona más apropiado para sus aplicaciones.

Mientras que las promesas siguen siendo un bloque de construcción fundamental, los observables desbloquean un nuevo nivel de expresividad y flexibilidad, particularmente en escenarios que implican flujos de datos y actualizaciones en tiempo real. Al dominar la transición de promesas a observables, los desarrolladores pueden liberar todo el potencial de la programación reactiva dentro del marco NestJS.

Fuente

Artículos Relacionados

Usando Pipes para transformar datos
· 5 min de lectura
Llama3 sacale el máximo provecho
· 4 min de lectura
Angular Signals: Mejores practicas
· 5 min de lectura