Введение

Каждое языкоспецифическое реализация ReactiveX реализует набор операторов. Хотя между реализациями существует значительное перекрытие, есть также операторы, реализованные только в определенных реализациях. Кроме того, каждая реализация, как правило, именует свои операторы, чтобы они напоминали похожие методы, которые уже знакомы из других контекстов на этом языке.

Операторы цепочки

Большинство операторов работают с Observable и возвращают Observable. Это позволяет применять эти операторы один за другим в цепочке. Каждый оператор в цепочке изменяет Observable, полученный в результате операции предыдущего оператора.

Существуют и другие паттерны, такие как паттерн Строитель, в котором различные методы определенного класса работают с элементом того же класса, изменяя этот объект посредством операции метода. Эти паттерны также позволяют объединять методы аналогичным образом. Но в то время как в паттерне Строитель порядок, в котором методы появляются в цепочке, обычно не имеет значения, с операторами Observable порядок имеет значение.

Цепочка операторов Observable не работает независимо от исходного Observable, порождающего цепочку, но работает последовательно, каждый оператор работает с Observable, сгенерированным оператором, непосредственно предшествующим ему в цепочке.

Операторы ReactiveX

На этой странице сначала перечислены операторы, которые можно считать «базовыми» в ReactiveX, и ссылки на страницы с более подробной информацией о работе этих операторов и о том, как реализованы эти операторы в конкретных языкоспецифических версиях ReactiveX.

Далее представлено «дерево принятия решений», которое может помочь вам выбрать оператор, наиболее подходящий для вашего случая.

Наконец, представлен алфавитный список большинства операторов, доступных во многих языкоспецифических реализациях ReactiveX. Эти ссылки ведут на страницу, которая документирует базовый оператор, наиболее похожий на языкоспецифический оператор (например, оператор Rx.NET «SelectMany» ссылается на документацию оператора ReactiveX FlatMap, из которого «SelectMany» является реализацией Rx.NET).

Если вы хотите реализовать свой собственный оператор, см. Реализация собственных операторов.

Содержание

Операторы по категориям
Дерево принятия решений для операторов Observable
Алфавитный список операторов Observable

Операторы по категориям

Создание Observable

Операторы, которые создают новые Observable.

Create — создает Observable с нуля, вызывая методы наблюдателя программно
Defer — не создает Observable до тех пор, пока наблюдатель не подпишется, и создает новый Observable для каждого наблюдателя
Empty/Never/Throw — создает Observable с очень точным и ограниченным поведением
From — преобразует какой-либо другой объект или структуру данных в Observable
Interval — создает Observable, который излучает последовательность целых чисел с определенным интервалом времени
Just — преобразует объект или набор объектов в Observable, который излучает этот или эти объекты
Range — создает Observable, который излучает диапазон последовательных целых чисел
Repeat — создает Observable, который многократно излучает определенный элемент или последовательность элементов
Start — создает Observable, который излучает возвращаемое значение функции
Timer — создает Observable, который излучает один элемент после заданной задержки

Преобразование Observable

Операторы, которые преобразуют элементы, излучаемые Observable.

Buffer — периодически собирает элементы из Observable в пакеты и излучает эти пакеты вместо того, чтобы излучать элементы по одному
FlatMap — преобразует элементы, излучаемые Observable, в Observable, затем уплощает излучения в единое Observable
GroupBy — разделяет Observable на набор Observable, каждый из которых излучает различную группу элементов из исходного Observable, организованных по ключу
Map — преобразует элементы, излучаемые Observable, применяя функцию к каждому элементу
Scan — последовательно применяет функцию к каждому элементу, излучаемому Observable, и излучает каждое последующее значение
Window — периодически разбивает элементы из Observable на окна Observable и излучает эти окна вместо того, чтобы излучать элементы по одному

Фильтрация Observable

Операторы, которые выборочно излучают элементы из исходного Observable.

Debounce — излучает элемент из Observable только в том случае, если определенный интервал времени прошел без излучения другого элемента
Distinct — подавляет дубликаты элементов, излучаемых Observable
ElementAt — излучает только элемент n, излучаемый Observable
Filter — излучает только те элементы из Observable, которые проходят проверку предиката
First — излучает только первый элемент или первый элемент, который удовлетворяет условию, из Observable
IgnoreElements — не излучает никаких элементов из Observable, но отражает уведомление о завершении
Last — излучает только последний элемент, излученный Observable
Sample — излучает самый последний элемент, излученный Observable, в определенные интервалы времени
Skip — подавляет первые n элементов, излучаемых Observable
SkipLast — подавляет последние n элементов, излучаемых Observable
Take — излучает только первые n элементов, излучаемых Observable
TakeLast — излучает только последние n элементов, излучаемых Observable

Объединение Observable

Операторы, которые работают с несколькими исходными Observable, чтобы создать одно Observable

And/Then/When — объединяет наборы элементов, излучаемых двумя или более Observable, с помощью Pattern и Plan посредников
CombineLatest — когда элемент излучается одним из двух Observable, объединяет последний элемент, излученный каждым Observable, с помощью заданной функции и излучает элементы, основанные на результатах этой функции
Join — объединяет элементы, излучаемые двумя Observable, всякий раз, когда элемент из одного Observable излучается в течение временного окна, определенного в соответствии с элементом, излученным другим Observable
Merge — объединяет несколько Observable в один, сливая их излучения
StartWith — излучает заданную последовательность элементов перед началом излучения элементов из исходного Observable
Switch — преобразует Observable, который излучает Observable, в одно Observable, которое излучает элементы, излучаемые самым последним из этих Observable
Zip — объединяет излучения нескольких Observable вместе с помощью заданной функции и излучает отдельные элементы для каждого сочетания, основанные на результатах этой функции

Операторы обработки ошибок

Операторы, которые помогают восстановиться от уведомлений об ошибках от Observable

Catch — восстанавливается от уведомления об onError , продолжая последовательность без ошибок
Retry — если исходное Observable отправляет уведомление onError, подписывается на него снова в надежде, что оно завершится без ошибок

Утилитарные операторы Observable

Набор полезных операторов для работы с Observable

Delay — сдвигает излучения из Observable вперед во времени на определенное количество
Do — регистрирует действие для выполнения в различных событиях жизненного цикла Observable
Materialize/Dematerialize — представляет как излучаемые элементы, так и отправленные уведомления как излучаемые элементы или выполняет обратное преобразование
ObserveOn — определяет планировщик, на котором наблюдатель будет наблюдать за этим Observable
Serialize — заставляет Observable выполнять сериализованные вызовы и вести себя корректно
Subscribe — работает с излучениями и уведомлениями от Observable
SubscribeOn — определяет планировщик, который Observable должен использовать при подписке
TimeInterval — преобразует Observable, который излучает элементы, в Observable, который излучает указания о времени, прошедшем между этими излучениями
Timeout — отражает исходное Observable, но отправляет уведомление об ошибке, если определенный период времени проходит без излучения каких-либо элементов
Timestamp — добавляет метку времени к каждому элементу, излучаемому Observable
Using — создает ресурс с освобождением, который имеет тот же жизненный цикл, что и Observable

Условные и логические операторы

Операторы, которые оценивают одно или несколько Observable или элементы, излучаемые Observable

All — определить, соответствуют ли все элементы, испускаемые наблюдаемым объектом, некоторым критериям
Amb — при наличии двух или более исходных наблюдаемых объектов, испускать все элементы только из первого из этих наблюдаемых объектов, который испустит элемент
Contains — определить, испускает ли наблюдаемый объект конкретный элемент или нет
DefaultIfEmpty — испускать элементы из исходного наблюдаемого объекта или стандартный элемент, если исходный наблюдаемый объект ничего не испускает
SequenceEqual — определить, испускают ли два наблюдаемых объекта одинаковую последовательность элементов
SkipUntil — отбрасывать элементы, испускаемые наблюдаемым объектом, до тех пор, пока второй наблюдаемый объект не испустит элемент
SkipWhile — отбрасывать элементы, испускаемые наблюдаемым объектом, пока указанное условие не станет ложным
TakeUntil — отбрасывать элементы, испускаемые наблюдаемым объектом, после того, как второй наблюдаемый объект испустит элемент или завершится
TakeWhile — отбрасывать элементы, испускаемые наблюдаемым объектом, после того, как указанное условие станет ложным

Математические и агрегатные операторы

Операторы, которые работают со всей последовательностью элементов, испускаемых наблюдаемым объектом

Average — вычисляет среднее значение чисел, испускаемых наблюдаемым объектом, и испускает это среднее значение
Concat — испускает испускания из двух или более наблюдаемых объектов без их переплетения
Count — подсчитывает количество элементов, испускаемых исходным наблюдаемым объектом, и испускает только это значение
Max — определяет и испускает элемент с максимальным значением, испускаемый наблюдаемым объектом
Min — определяет и испускает элемент с минимальным значением, испускаемый наблюдаемым объектом
Reduce — последовательно применяет функцию к каждому элементу, испускаемому наблюдаемым объектом, и испускает конечное значение
Sum — вычисляет сумму чисел, испускаемых наблюдаемым объектом, и испускает эту сумму

Операторы обратной загрузки

операторы обратной загрузки — стратегии для работы с наблюдаемыми объектами, которые производят элементы быстрее, чем их наблюдатели их потребляют

Подключаемые наблюдаемые операторы

Специализированные наблюдаемые объекты, которые имеют более точно контролируемые динамику подписки

Connect — указывает подключенному наблюдаемому объекту начать испускать элементы своим подписчикам
Publish — преобразует обычный наблюдаемый объект в подключенный наблюдаемый объект
RefCount — заставляет подключенный наблюдаемый объект вести себя как обычный наблюдаемый объект
Replay — гарантирует, что все наблюдатели видят одну и ту же последовательность испускаемых элементов, даже если они подписываются после того, как наблюдаемый объект начал испускать элементы

Операторы преобразования наблюдаемых объектов

To — преобразует наблюдаемый объект в другой объект или структуру данных

Дерево решений наблюдаемых операторов

Это дерево поможет вам найти оператор ReactiveX Observable, который вы ищете.

Я хочу создать новый Observable

который испускает конкретный элемент

Just

который был возвращен из функции, вызываемой во время подписки: Start
который был возвращен из Action, Callable, Runnable, или что-то подобного, вызываемого во время подписки: From
через указанную задержку: Timer

который получает свои испускания из конкретного Array, Iterable, или чего-то подобного

From

получая его из Future

Start

который получает свою последовательность из Future

From

который испускает последовательность элементов многократно

Repeat

с нуля, с пользовательской логикой

Create

для каждого наблюдателя, который подписывается

Defer

который испускает последовательность целых чисел

Range

с определенными интервалами времени

Interval

через указанную задержку: Timer

который завершается без испускания элементов

Empty

который ничего не делает

Never

Я хочу создать Observable, комбинируя другие Observables

и испускать все элементы из всех Observables в любом порядке их получения

Merge

и испускать все элементы из всех Observables, по одному Observable за раз

Concat

комбинируя элементы из двух или более Observables последовательно, чтобы получить новые элементы для испускания

когда каждый из Observables испустил новый элемент: Zip
когда любой из Observables испустил новый элемент: CombineLatest
когда элемент испускается одним Observable в окне, определенном элементом, испущенным другим: Join
с помощью Pattern и Plan посредников: And/Then/When

и испускать элементы только из наиболее недавно испущенного из этих Observables

Switch

Я хочу испускать элементы из Observable после их преобразования

по одному за раз с помощью функции

Map

испуская все элементы, испущенные соответствующими Observables

FlatMap

одно Observable за раз, в порядке их испускания: ConcatMap

на основе всех элементов, которые их предшествовали

Scan

добавляя к ним метку времени

Timestamp

в индикатор времени, который прошел до испускания элемента

TimeInterval

Я хочу сдвинуть элементы, испускаемые Observable, вперед во времени перед их повторным испусканием

Delay

Я хочу преобразовать элементы и уведомления из Observable в элементы и повторно испускать их

упаковывая их в Notification объекты

Materialize

которые я затем могу распаковать с помощью: Dematerialize

Я хочу проигнорировать все элементы, испускаемые Observable, и передать только завершение/ошибку

IgnoreElements

Я хочу отобразить Observable, но добавить префикс к его последовательности

StartWith

только если его последовательность пуста: DefaultIfEmpty

Я хочу собрать элементы из Observable и повторно испускать их как буферы элементов

Buffer

содержащие только последние испущенные элементы: TakeLastBuffer

Я хочу разделить одно Observable на несколько Observables

Window

так, чтобы похожие элементы оказывались в одном Observable: GroupBy

Я хочу получить определенный элемент, испущенный Observable:

последний элемент, испущенный перед завершением: Last
единственный элемент, который он испустил: Single
первый элемент, который он испустил: First

Я хочу повторно испускать только определенные элементы из Observable

фильтруя те, которые не соответствуют некоторому предикату

Filter

то есть только первый элемент

First

то есть только первые элементы

Take

то есть только последний элемент

Last

то есть только элемент n

ElementAt

то есть только те элементы после первых элементов

то есть после первых n элементов: Skip
то есть до тех пор, пока один из этих элементов не соответствует предикату: SkipWhile
то есть после начального периода времени: Skip
то есть после того, как другое Observable испустило элемент: SkipUntil

то есть те элементы, за исключением последних элементов

то есть за исключением последних n элементов: SkipLast
то есть до тех пор, пока один из этих элементов не соответствует предикату: TakeWhile
то есть за исключением элементов, испущенных в течение периода времени до завершения источника: SkipLast
то есть за исключением элементов, испущенных после того, как другое Observable испустило элемент: TakeUntil

дискретно отбирая элементы Observable периодически

Sample

испуская только те элементы, за которыми не следуют другие элементы в течение некоторой продолжительности

Debounce

подавляя элементы, которые являются дубликатами уже испущенных элементов

Distinct

если они следуют сразу за элементом, являющимся их дубликатом: DistinctUntilChanged

задерживая мою подписку на него на некоторое время после того, как он начнет испускать элементы

DelaySubscription

Я хочу повторно испускать элементы из Observable только в том случае, если это был первый из набора Observables, испустивший элемент

Amb

Я хочу оценить всю последовательность элементов, испущенных Observable

и испустить одно булево значение, указывающее, проходят ли все элементы некоторый тест: All
и испустить одно булево значение, указывающее, испустило ли Observable любой элемент (который проходит некоторый тест): Contains
и испустить одно булево значение, указывающее, испустило ли Observable ни одного элемента: IsEmpty
и испустить одно булево значение, указывающее, идентична ли последовательность последовательности, испущенной другим Observable: SequenceEqual
и испустить среднее значение всех их значений: Average
и испустить сумму всех их значений: Sum
и испустить число, указывающее, сколько элементов было в последовательности: Count
и испустить элемент с максимальным значением: Max
и испустить элемент с минимальным значением: Min
применяя функцию агрегации к каждому элементу по очереди и испуская результат: Scan

Я хочу преобразовать всю последовательность элементов, испущенных Observable, в другую структуру данных

Я хочу оператор, который работает на определенном Scheduler

SubscribeOn

когда он уведомляет наблюдателей: ObserveOn

Я хочу, чтобы Observable вызывал определенное действие при наступлении определенных событий

Я хочу Observable, который уведомит наблюдателей об ошибке

Throw

если указанный период времени истекает без испускания им элемента: Timeout

Я хочу, чтобы Observable восстанавливался плавно

из таймаута, переключаясь на резервное Observable

Timeout

из уведомления об ошибке от предшественника

Catch

попытаясь повторно подписаться на исходное Observable: Retry

Я хочу создать ресурс, имеющий тот же срок службы, что и Observable

Using

Я хочу подписаться на Observable и получить Future , который блокируется до завершения Observable

Start

Я хочу Observable, который не начнет испускать элементы подписчикам, пока не попросят

Publish

и затем испустит только последний элемент в своей последовательности: PublishLast
и затем испустит всю последовательность, даже тем, кто подписывается после начала последовательности: Replay
но я хочу, чтобы он исчез, когда все его подписчики отменят подписку: RefCount
и затем я хочу попросить его начать: Connect

См. также

Какой оператор использовать? by Dennis Stoyanov (аналогичное дерево решений, специфичное для операторов RxJS)

Алфавитный список операторов Observable

Канонические, основные имена операторов выделены полужирным шрифтом. Другие записи представляют языковые варианты этих операторов или специализированные операторы, не входящие в основной набор операторов ReactiveX.

if
ifThen
IgnoreElements
indexOf
interleave
interpose
Interval
intervalRange
into
isEmpty
items
Join
join (строка)
jortSort
jortSortUntil
Just
keep
keep-indexed
Last
lastElement
lastOption
LastOrDefault
lastOrElse
Latest
latest (Rx.rb версия Switch)
length
let
letBind
lift
limit
LongCount
ManySelect
Map
map (RxClojure версия Zip)
MapCat
mapCat (RxClojure версия Zip)
map-indexed
mapTo
mapWithIndex
Materialize
Max
MaxBy
Merge
mergeAll
mergeArray
mergeArrayDelayError
merge_concurrent
mergeDelayError
mergeObservable
mergeWith
Min
MinBy
MostRecent
Multicast
multicastWithSelector
nest
Never
Next
Next (версия BlockingObservable)
none
nonEmpty
nth
ObserveOn
ObserveOnDispatcher
observeSingleOn
of
of_array
ofArrayChanges
of_enumerable
of_enumerator
ofObjectChanges
OfType
ofWithScheduler
onBackpressureBlock
onBackpressureBuffer
onBackpressureDrop
OnErrorResumeNext
onErrorReturn
onErrorReturnItem
onExceptionResumeNext
onTerminateDetach
orElse
pairs
pairwise
partition
partition-all
pausable
pausableBuffered
pluck
product
Publish
PublishLast
publish_synchronized
publishValue
raise_error
Range
Reduce
reduceWith
reductions
RefCount
Repeat
repeat_infinitely
repeatUntil
repeatWhen
Replay
rescue_error
rest
Retry
retry_infinitely
retryUntil
retryWhen
Return
returnElement
returnValue
runAsync
safeSubscribe
Sample
Scan
scanWith
scope
Select (альтернативное имя Map)
select (альтернативное имя Filter)
selectConcat
selectConcatObserver
SelectMany
selectManyObserver
select_switch
selectSwitch
selectSwitchFirst
selectWithMaxConcurrent
select_with_index
seq
SequenceEqual
sequence_eql?
SequenceEqualWith
Serialize
share
shareReplay
shareValue
Single
singleElement
SingleOrDefault
singleOption
singleOrElse
size
Skip
SkipLast
skipLastWithTime
SkipUntil
skipUntilWithTime
SkipWhile
skipWhileWithIndex
skip_with_time
slice
sliding
slidingBuffer
some
sort
sorted
sort-by
sorted-list-by
split
split-with
Start
startAsync
startFuture
StartWith
startWithArray
stringConcat
stopAndWait
subscribe
subscribeActual
SubscribeOn