then - ¿Cuáles son las diferencias entre observables y promesas en JavaScript?
then javascript (5)
He leído que los observables buscan superar las promesas en términos de uso en algunos de los próximos MVC de JavaScript:
¿Cuál es la diferencia entre observables y promesas?
Actualizado: disculpas! eliminado mi declaración falsa.
¿Cuál es la diferencia entre observables y promesas?
En pocas palabras: una promesa se resuelve en un solo valor de forma asíncrona, un observable resuelve (o emite) múltiples valores de forma asíncrona (a lo largo del tiempo).
Ejemplos concretos:
- Promesa: Respuesta de una llamada Ajax
- Observable: haga clic en eventos
Puede encontrar más información aquí: reactivex.io/intro.html
He leído que los observables buscan superar las promesas
Improbable. Los observables pueden ser la mejor solución para ciertos problemas, pero eso no hace que las promesas se vuelvan obsoletas (si eso es lo que quieres decir).
Las promesas ofrecen un mecanismo de devolución de llamada muy simplista, mientras que Rx ofrece una abstracción poderosa sobre la programación asíncrona. Un observable representa un flujo de datos, al que podemos aplicar los operadores para definir cómo deben tratarse los datos entrantes.
Si todo lo que necesita hacer es realizar una solicitud HTTP y luego actualizar un componente de UI, entonces puede ser suficiente usar una Promesa.
Sin embargo, la mayoría de las aplicaciones tienden a tener necesidades más complicadas que eso (incluso si no son obvias al principio). Tomando por ejemplo nuestra solicitud HTTP, veamos cómo modelar esto como un Observable y usar algunos de los operadores Rx puede ayudarnos a:
-Si la solicitud HTTP es activada por una acción del usuario, es posible que tengamos cuidado de no disparar múltiples solicitudes HTTP (imagine un usuario escribiendo en un cuadro de búsqueda). No queremos disparar una solicitud por cada pulsación de tecla, por lo que es posible que desee Acelerar nuestra búsqueda, de modo que solo disparemos una solicitud si el usuario deja de escribir 300 ms. Además, si el usuario escribe una palabra, espera 300 ms y agrega otro carácter, iniciaremos una solicitud HTTP posterior. Con Promises, probablemente nos encontraremos con una condición de carrera, ya que no podemos controlar el orden en el que recibiremos las respuestas y no podremos cancelar las solicitudes anteriores. Rx resuelve esto permitiéndonos cambiar entre flujos, lo que llama a Desechar las suscripciones de solicitudes anteriores que ya no nos interesan. También podríamos filtrar cualquier entrada de búsqueda no válida, por ejemplo, donde el término de búsqueda tiene menos de 3 caracteres de longitud.
-Apoyo para tratar con tiempos de espera / manejo de errores. Digamos que nuestra solicitud HTTP falla, Rx nos permite reintentar fácilmente haciendo la solicitud.
-Digamos que varias partes de nuestra aplicación necesitan hacer la misma llamada HTTP, probablemente no queremos hacer la llamada más de una vez. Podemos exponer nuestro observable a múltiples consumidores y usar Replay para garantizar que la llamada se realice una vez y el resultado se almacene en caché para los subscriptores posteriores. Incluso podemos proporcionar un TimeSpan a Replay, dándonos un comportamiento de caché que caduca.
-Una poderosa abstracción sobre el uso de Programadores, lo que nos permite controlar la concurrencia. Aún mejor, podemos usar los programadores de pruebas en nuestras pruebas unitarias para controlar el tiempo, lo que nos permite simular tiempos de espera, condiciones de carrera, etc.
Estos son algunos ejemplos rápidos para demostrar lo que es posible. Hay muchos más operadores dentro del marco de Rx para atender a todos los tipos de escenarios y la capacidad de composición de Rx significa que puede combinar operadores fácilmente para definir el comportamiento que necesita. También es fácil crear sus propios operadores reutilizables (por ejemplo, RetryAfterDelay).
En resumen, Rx puede hacer todo lo que Promises puede hacer, y mucho más. Sospecho que en los próximos años habrá un cambio continuo hacia Rx en lugar de Promises.
Para más información, recomiendo echar un vistazo a la sección de Observables en la guía Angular 2 .
Las promesas son una representación de 1 valor futuro. Los observables son una representación para una cantidad de valores posiblemente infinita.
Las promesas activarán la obtención de ese valor inmediatamente después de la creación. Los observables solo comenzarán a producir valores cuando te suscribas a ellos. (A menos que sea un observable, pero eso está fuera del alcance de esta pregunta)
Las promesas están diseñadas para representar las llamadas AJAX. Los observables están diseñados para representar cualquier cosa: eventos, datos de bases de datos, datos de llamadas ajax, (posiblemente infinitas) secuencias, etc.
Los observables son a menudo comparados con las promesas. Aquí hay algunas diferencias clave:
Los observables son declarativos; El cálculo no comienza hasta la suscripción. Las promesas se ejecutan inmediatamente en la creación. Esto hace que los observables sean útiles para definir recetas que se pueden ejecutar siempre que necesite el resultado.
Los observables proporcionan muchos valores. Las promesas proporcionan uno. Esto hace que los observables sean útiles para obtener múltiples valores a lo largo del tiempo.
Los observables diferencian entre el encadenamiento y la suscripción. Las promesas solo tienen cláusulas .then (). Esto hace que los elementos observables sean útiles para crear recetas de transformación complejas para ser utilizadas por otra parte del sistema, sin causar que el trabajo se ejecute.
Observables subscribe () es responsable de manejar los errores. Las promesas empujan los errores a las promesas infantiles. Esto hace que los observables sean útiles para el manejo centralizado y predecible de errores.
Mejor explicación por angular en la página web oficial:
como se dice en angular 2 guid
La conversión a una Promesa suele ser una buena opción cuando se desea obtener una sola porción de datos. así que cuando recibas los datos, ya está.
Pero en algunos casos las solicitudes no siempre se hacen una sola vez. Puede iniciar una solicitud, cancelarla y realizar una solicitud diferente antes de que el servidor haya respondido a la primera solicitud.
por ejemplo, en un componente de búsqueda A medida que el usuario escribe un nombre en un cuadro de búsqueda, realizarás solicitudes HTTP repetidas por esa consulta de búsqueda.
Es difícil implementar una secuencia de solicitud-cancelación-nueva-solicitud con Promesas, pero fácil con Observables.
por lo tanto, si su componente obtiene datos con una sola solicitud, es una buena opción usar Promise pero si tiene una cadena de solicitudes de solicitud-cancelación-nueva, debe usar observable