¿Cuáles son los operadores utilizados por RxJava para eliminar la fluctuación y evitar clics repetidos en los botones?

Cada implementación del lenguaje de programación de ReactiveX implementa un conjunto de operadores. Existe mucha superposición entre diferentes implementaciones y algunos operadores solo existen en implementaciones específicas. Cada implementación tiende a nombrar estos operadores de manera similar al contexto en el que están familiarizados con ese lenguaje de programación.

Este artículo primero brindará una lista de los operadores principales de ReactiveX y los enlaces de los documentos correspondientes, seguido de un árbol de decisiones para ayudarlo a elegir el operador apropiado de acuerdo con escenarios específicos. Finalmente hay una lista alfabética de operadores para implementaciones específicas del idioma.

Si desea implementar su propio operador, puede consultar aquí: Implementación de operadores personalizados

Creación de operaciones

Operadores utilizados para crear Observable

Crear: cree un Observable desde cero llamando al método del observador

Aplazar: no cree este Observable antes de que el observador se suscriba, cree un nuevo Observable para cada observador

Vacío/Nunca /Throw: crea un Observable especial con comportamiento restringido

Desde: convierte otros objetos o estructuras de datos en Observable

Intervalo: crea un Observable entero de secuencias de emisión temporizada

Solo — Convertir un objeto o colección de objetos en un Observable que emita esos objetos

Rango — Crear un Observable que emita una secuencia de números enteros en un rango específico

Repetir — Crear un Observable que emite repetidamente datos o secuencia de datos específicos

Inicio: crea un Observable que emite el valor de retorno de una función

Temporizador: crea un Observable que emite un único valor después de un retraso especificado Observable de datos

Operaciones de transformación

Estos operadores se pueden utilizar para transformar los datos emitidos por Observable. Para una explicación detallada, consulte la documentación de cada operador.

Buffer: el caché puede entenderse simplemente como almacenamiento en caché que recopila periódicamente datos de Observable en una colección y luego empaqueta y transmite estas colecciones de datos en lugar de emitir uno a la vez.

FlatMap: mapeo plano, que convierte los datos emitidos por Observable Transformar en una colección de Observables, y luego aplanar los datos emitidos por estos Observables en un solo Observable, puede considerarse como un proceso de despliegue de una estructura de datos anidada.

GroupBy: agrupa, divide el Observable original en colecciones de Observable, agrupa los datos emitidos por el Observable original por clave y cada Observable emite un conjunto diferente de datos

Map: Mapeo, aplicando una función a cada elemento de la secuencia para transformar los datos emitidos por el Observable, la esencia es ejecutar una función en cada elemento de la secuencia, y el parámetro de la función es el elemento de datos

Escanear — escanear, para aplicar una función a cada elemento de datos emitido por el Observable y luego emitir estos valores en secuencia

Ventana — Ventana, divide periódicamente los datos del Observable en varios Observables ventanas y luego emitir estas ventanas, en lugar de cada Iniciar un elemento a la vez.

Similar a Buffer, pero Buffer emite datos y Window emite Observable. Cada Observable emite un subconjunto de los datos del Observable original.

Operaciones de filtrado

Estos operadores se utilizan para seleccionar entre los datos emitidos por. Observable

Debounce: solo emite datos después de que han estado inactivos durante un período de tiempo. En términos sencillos, si no hay ninguna operación durante un período de tiempo, realice una operación

. Distinto: deduplicación, filtra elementos de datos duplicados

ElementAt: valor, obtiene elementos de datos en posiciones específicas

Filtro: filtra, filtra elementos de datos que no han pasado la prueba de predicado, únicamente Emite aquellos que pasan la prueba

Primero: el primer elemento, solo emite el primer dato que cumpla las condiciones

IgnoreElements: ignora todos los datos, solo conserva la notificación de terminación (onError o onCompleted)

p>

Último: último elemento, solo se emite el último dato.

Muestra: muestreo, los datos más recientes se emiten periódicamente, lo que equivale a muestreo de datos En algunas implementaciones, se llama ThrottleFirst

Omitir: omitir los elementos de datos anteriores

Omitir las últimas opciones: omitir los siguientes elementos de datos

Tomar: Mantenga solo los elementos de datos anteriores

TakeLast: conserve solo los siguientes elementos de datos

Operación de combinación

El operador de combinación se utiliza para combinar múltiples Observables en un solo Observable

Y/Entonces/Cuándo: combina los conjuntos de datos emitidos por dos o más Observables a través de patrones (y condiciones) y planes (luego ordena)

CombineLatest: cuando cualquiera de los dos Observables emiten datos, pasan un especificado La función combina los últimos datos (uno o dos datos) emitidos por cada Observable y luego emite el resultado de esta función

Unirse: siempre que un Observable emite datos elemento, siempre que dentro de la ventana de tiempo definida por el elemento de datos emitido por otro Observable, los datos emitidos por los dos Observables se fusionen y emitan

Fusionar: fusionar los datos emitidos por los dos Observables en uno

StartWith: emite una secuencia de datos o elemento de datos especificado antes de emitir la secuencia de datos del Observable original.

Switch: convierte un Observable que emite una secuencia de Observables en un Observable que emite los Observables más recientes. Datos emitidos uno por uno

Zip: empaquetar, usar una función específica para combinar los datos emitidos por múltiples Observables y luego emitir el resultado de esta función como un solo elemento de datos

Manejo de errores

Estos operadores se utilizan para recuperarse de notificaciones de error

Capturar: capturar, continuar la operación de secuencia, reemplazar el error con datos normales y recuperarse de notificaciones de error

Reintentar: reintentar si el Observable emite una notificación de error, vuelva a suscribirse y espere que finalice normalmente

Operaciones auxiliares

Un conjunto de operadores para procesar Observables

Retraso: retrasa la emisión de datos de resultados durante un período de tiempo.

Hacer: registra una acción para ocupar algunos eventos del ciclo de vida observables, lo que equivale a simular una operación.

p>Materializar/Desmaterializar: trata los datos emitidos y las notificaciones como emisiones de datos, o viceversa.

ObserveOn: especifica el observador para que observe el programador del Observable (subproceso de trabajo).

Serializar: fuerza la Observable para emitir datos en orden y la función es válida

Subscribe: la operación que se realizará después de recibir los datos y notificaciones emitidas por el Observable

SubscribeOn: especifica qué programador debe realizar el Observable ejecutar en

TimeInterval: convierte un Observable en un Observable que toma el tiempo entre la emisión de dos datos.

Timeout: agrega un mecanismo de tiempo de espera, si no se emiten datos después de un período de tiempo específico. , Emitir una notificación de error

Marca de tiempo: agrega una marca de tiempo a cada elemento de datos emitido por el Observable

Uso: crea un recurso único que solo existe durante la vida útil del Observable

p>

Operaciones condicionales y booleanas

Estos operadores se pueden usar para elementos de datos únicos o múltiples, y también se pueden usar para Observables

Todos - determinar si todos los elementos de datos emitidos por el Observable Todos cumplen una determinada condición

Amb: dados varios Observables, solo el primer Observable que emita datos emitirá todos los datos

Contiene: determina si el Observable emitirá un elemento de datos específico.

DefaultIfEmpty: emite datos del Observable original. Si el Observable original no emite datos, emite datos predeterminados.

SequenceEqual: determina si dos Observables son. en la misma secuencia de datos

p>

SkipUntil: descarta los datos emitidos por el Observable original hasta que el segundo Observable emite un elemento, luego emite los datos restantes del Observable original

SkipWhile: descarta los datos emitidos por el Observable original hasta que una condición específica sea falsa, luego emite los datos restantes del Observable original

TakeUntil: emite datos del Observable original hasta que el segundo Observable emite un dato. o una notificación

TakeWhile: emite datos de Raw Observable hasta que una condición específica sea verdadera, luego omite los datos restantes

Operaciones aritméticas y de agregación

Estos operadores pueden ser utilizado en toda la secuencia de datos

Promedio: calcula el promedio de la secuencia de datos emitida por el Observable y luego emite el resultado

Concat: conecta los datos de múltiples Observables sin entrelazar

Recuento: calcula los datos emitidos por el número observable y luego emite el resultado

Max: calcula y emite el valor máximo de la secuencia de datos

Min: calcula y emite el valor mínimo de la secuencia de datos

Reducir: aplica una función a cada una de las secuencias de datos en secuencia y devuelve este valor

Suma: calcula y emite la suma de los secuencias de datos

Operaciones de unión

Algunos Observables especiales con comportamiento de suscripción controlable con precisión

Conectar: ​​indica a un Observable conectable que comience a emitir datos a los suscriptores

Publicar: convertir un Observable normal en uno que se pueda unir.

RefCount: hacer que un Observable que se pueda unir se comporte como un Observable normal.

Reproducir: garantizar que todos los observadores reciban lo mismo. secuencia de datos, incluso si se suscriben después de que el Observable comience a emitir datos

Operación de conversión

Para: convertir el Observable en otro objeto o estructura de datos

Bloqueo de bloqueo Operador observable

Árbol de decisión del operador

Varios requisitos principales

Crear un Observable directamente (crear operación)

Combinar múltiples Observables (operación combinada )

Realizar operaciones de transformación (operaciones de transformación) sobre los datos emitidos por el Observable

Obtener datos específicos de los datos emitidos por el valor Observable (operación de filtrado)

Reenviar algunos valores de Observable (operación condicional/booleana/filtro)

Evaluar la secuencia de datos emitida por Observable (operación aritmética/agregación)