En la programación de software , ReactiveX (también conocido como Reactive Extensions ) es un conjunto de herramientas que permiten que los lenguajes de programación imperativos operen en secuencias de datos independientemente de si los datos son síncronos o asincrónicos . Proporciona un conjunto de operadores de secuencia que operan en cada elemento de la secuencia. Es una implementación de programación reactiva y proporciona un modelo para que las herramientas se implementen en múltiples lenguajes de programación .
Otros nombres | Extensiones reactivas |
---|---|
Autor (es) original (es) | Microsoft |
Desarrollador (es) | Contribuyentes de ReactiveX |
Versión inicial | 21 de junio de 2011 |
Repositorio | github |
Escrito en | Java , Scala , C # , C ++ , Clojure , JavaScript , Python , Groovy , JRuby y otros |
Plataforma | Multiplataforma |
Tipo | API |
Licencia | Licencia Apache 2.0 , Licencia MIT |
Sitio web | reactivox |
Descripción general
ReactiveX es una API para programación asincrónica con flujos observables. [1]
La programación asincrónica permite a los programadores llamar a funciones y luego hacer que las funciones "devuelvan la llamada" cuando se terminan, generalmente dándole a la función la dirección de otra función para que se ejecute cuando esté lista. Los programas diseñados de esta manera a menudo evitan la sobrecarga de tener muchos subprocesos que se inician y se detienen constantemente.
Los flujos observables (es decir, los flujos que se pueden observar) en el contexto de las extensiones reactivas son como emisores de eventos que emiten tres eventos: siguiente, error y completo. Un observable emite los siguientes eventos hasta que emite un evento de error o un evento completo. Sin embargo, en ese momento no emitirá más eventos, a menos que se suscriba nuevamente.
Motivación
Para secuencias de datos, combina las ventajas de los iteradores con la flexibilidad de la programación asincrónica basada en eventos. También funciona como una simple promesa, eliminando la pirámide de fatalidad que resulta de múltiples capas de devoluciones de llamada.
Observables y observadores
ReactiveX es una combinación de ideas del observador y los patrones del iterador y de la programación funcional . [2]
Un observador se suscribe a una secuencia observable. Luego, la secuencia envía los elementos al observador uno a la vez, generalmente llamando a la función de devolución de llamada proporcionada. El observador maneja cada uno antes de procesar el siguiente. Si muchos eventos entran de forma asincrónica, deben almacenarse en una cola o descartarse. En ReactiveX, nunca se llamará a un observador con un elemento fuera de servicio o (en un contexto de subprocesos múltiples) antes de que la devolución de llamada haya regresado para el elemento anterior. Las llamadas asincrónicas permanecen asincrónicas y pueden manejarse devolviendo un observable.
Es similar al patrón de iteradores en que si ocurre un error fatal, notifica al observador por separado (llamando a una segunda función). Cuando se han enviado todos los elementos, se completa (y notifica al observador llamando a una tercera función). La API de Reactive Extensions también toma prestados muchos de sus operadores de operadores iteradores en otros lenguajes de programación.
Reactive Extensions es diferente de la programación reactiva funcional, como explica la Introducción a Reactive Extensions:
A veces se le llama "programación reactiva funcional", pero es un nombre inapropiado. ReactiveX puede ser funcional y puede ser reactivo, pero la "programación reactiva funcional" es un animal diferente. Un punto principal de diferencia es que la programación reactiva funcional opera con valores que cambian continuamente con el tiempo, mientras que ReactiveX opera con valores discretos que se emiten con el tiempo. (Consulte el trabajo de Conal Elliott para obtener información más precisa sobre la programación reactiva funcional). [2]
Operadores reactivos
Un operador es una función que toma un observable (la fuente) como su primer argumento y devuelve otro observable (el destino o el observable externo). Luego, para cada elemento que emite el observable de origen, aplicará una función a ese elemento y luego lo emitirá en el Observable de destino. Incluso puede emitir otro Observable sobre el destino observable. A esto se le llama un observable interno.
Un operador que emite observables internos puede ser seguido por otro operador que de alguna manera combina los elementos emitidos por todos los observables internos y emite el elemento en su observable externo. Ejemplos incluyen:
switchAll
- se suscribe a cada nuevo observable interno en cuanto se emite y se da de baja del anterior.mergeAll
- se suscribe a todos los observables internos a medida que se emiten y genera sus valores en el orden en que los reciba.concatAll
- se suscribe a cada observable interno en orden y espera a que se complete antes de suscribirse al siguiente observable.
Los operadores se pueden encadenar para crear flujos de datos complejos que filtran eventos en función de ciertos criterios. Se pueden aplicar varios operadores al mismo observable.
Algunos de los operadores que se pueden usar en Reactive Extensions pueden ser familiares para los programadores que usan un lenguaje de programación funcional, como map, reduce, group y zip. [3] Hay muchos otros operadores disponibles en Reactive Extensions, aunque los operadores disponibles en una implementación particular para un lenguaje de programación pueden variar.
Ejemplos de operadores reactivos
A continuación se muestra un ejemplo de cómo utilizar el mapa y reducir los operadores. Creamos un observable a partir de una lista de números. El operador del mapa luego multiplicará cada número por dos y devolverá un observable. El operador de reducción luego sumará todos los números que se le proporcionen (el valor de 0 es el punto de partida). Al llamar a subscribe se registrará un observador que observará los valores del observable producido por la cadena de operadores. Con el método de suscripción, podemos pasar una función de manejo de errores, llamada siempre que se emite un error en el observable, y una función de finalización cuando el observable ha terminado de emitir elementos.
sourceObservable = Rx . Observable . de ([ 1 , 2 , 3 , 4 , 5 ]); sourceObservable . mapa ( función ( número ) { número de retorno * 2 ; }) . reducir ( función ( suma , número ) { devolver suma + número ; }, 0 ) . subscribe ( función ( número ) { consola . registro ( número ); }, función ( error ) { consola . error ( error ); }, función () { consola . log ( 'hecho' ); })
El ejemplo anterior utiliza la implementación Rx.js de Reactive Extensions para el lenguaje de programación JavaScript.
Historia
Reactive Extensions (Rx) fue inventado por el equipo de programación en la nube de Microsoft alrededor de 2011, como un subproducto de un esfuerzo mayor llamado Volta . Originalmente, estaba destinado a proporcionar una abstracción para eventos en diferentes niveles en una aplicación para admitir la división de niveles en Volta. El logo del proyecto representa una anguila eléctrica, que es una referencia a Volta. El sufijo de extensiones en el nombre es una referencia a la tecnología de extensiones paralelas que se inventó aproximadamente al mismo tiempo; los dos se consideran complementarios.
La implementación inicial de Rx fue para .NET Framework y se lanzó el 21 de junio de 2011. Posteriormente, el equipo comenzó la implementación de Rx para otras plataformas, incluidas JavaScript y C ++ . La tecnología se lanzó como código abierto a finales de 2012, inicialmente en CodePlex . Más tarde, el código se trasladó a GitHub .
Referencias
- ^ "ReactiveX" . reactivex.io . Consultado el 20 de febrero de 2020 .
- ^ a b "ReactiveX - Introducción" . ReactiveX.io . Consultado el 23 de septiembre de 2018 .
- ^ "ReactiveX - Operadores" . ReactiveX.io . Consultado el 23 de septiembre de 2018 .
enlaces externos
- ReactiveX , sitio web de extensiones reactivas con documentación y lista de implementación
- ReactiveX en GitHub