es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Patrón para mantener un servicio libre de efectos secundarios en la programación reactiva funcional.

Soy un traductor de español que traduce documentos de TI. Traduzca lo siguiente al español. No traduzca el código y la salida en markdown.

Soy bastante nuevo en la programación reactivo funcional y tengo una pregunta sobre cómo diseñar un servicio (una clase dentro de la interfaz de usuario de mi aplicación web) que crea un modelo de vista de un gráfico.

Por ahora, es así:

Para usar este servicio, paso algunos flujos de entrada como parámetros y obtengo un flujo de salida.

Uno de esos flujos de entrada emitirá un evento si el gráfico debe cargar nuevos datos, otro flujo de entrada emitirá un evento si cambia el rango de tiempo seleccionado, y así sucesivamente. El flujo de respuesta emite modelos de vista.

Entonces la llamada se ve así:

const viewModel $ = lineChart.createChart (timeRange $, refresh $)

viewModel $.subscribe ((viewModel) => renderMyChart (viewModel))

Ahora no quiero que este servicio cree efectos secundarios. En este momento, el servicio está haciendo una solicitud http al backend, pero quiero extraer esta llamada y me pregunto cómo se hace generalmente en la programación reactivo funcional.

Mi idea hasta ahora es que también devolvería un flujo de evento cada vez que el servicio decida pedir nuevos datos. Y también pasaría un flujo de entrada que emitiría esos datos (las respuestas de la solicitud http):

const [requestData$, viewModel$] = lineChart.createChart (timeRange$, refresh$, data $)

requestData$.subscribe ((solicitud) => {
someService.fetchData (solicitud) .subscribe ((respuesta) => data $ .next (respuesta))
})

viewModel$.subscribe ((viewModel) => renderMyChart (viewModel))

Para mí, parece un poco extraño pasar un flujo de datos y haber devuelto dos flujos y copiar las respuestas al flujo de datos. ¿Cómo se hace esto generalmente? ¿Existen patrones comunes para eso?

Tags:  , , , ,

Answer

  1. Avatar for davy.ai

    En la programación funcional reactiva, es importante evitar los efectos secundarios y mantener el programa lo más declarativo posible. Un patrón común para manejar solicitudes HTTP es utilizar el operador switchMap para mapear el flujo de eventos de entrada (por ejemplo, eventos de actualización) en un flujo de salida de mensajes de respuesta HTTP. Aquí hay un ejemplo:

    // Crear un subject para recibir eventos de actualización
    const refresh$ = new BehaviorSubject<void>(undefined);
    
    // Utilizar switchMap para mapear eventos de actualización a solicitudes HTTP
    const response$ = refresh$.pipe(
      switchMap(() => someService.fetchData(/* parámetros de solicitud */))
    );
    
    // Suscribirse al flujo de respuesta para actualizar el modelo de vista
    const viewModel$ = combineLatest([timeRange$, response$]).pipe(
      map(([timeRange, data]) => createViewModel(timeRange, data))
    );
    
    viewModel$.subscribe((viewModel) => renderMyChart(viewModel));
    
    // Disparar un evento de actualización
    refresh$.next();
    

    En este ejemplo, el operador switchMap se usa para mapear eventos de actualización a solicitudes HTTP. Cuando se emite un nuevo evento de actualización en el flujo de entrada, se llama al método fetchData con los parámetros requeridos, y la respuesta HTTP resultante se emite en el flujo de salida.

    El operador combineLatest se utiliza para combinar el flujo de tiempo del rango de entrada con el flujo de respuesta HTTP para crear un modelo de vista. El operador map se utiliza para transformar el rango de tiempo y los datos de respuesta en un objeto de modelo de vista.

    Al utilizar este patrón, evitamos que el servicio cree efectos secundarios como hacer solicitudes HTTP directamente. En su lugar, utilizamos observables para representar el flujo de eventos y datos en toda la aplicación.

Comments are closed.