Окно
периодически разбивает элементы из Observable на Observable-окна и испускает эти окна вместо испускания элементов по одному
Окно похож на Буфер, но вместо испускания пакетов элементов из исходного Observable, он испускает Observable, каждый из которых испускает подмножество элементов из исходного Observable, а затем завершается с уведомлением onCompleted.
Как и Буфер, у Окна есть много разновидностей, каждая со своим способом разделения исходного Observable на испускаемые Observable-результаты, каждый из которых содержит «окно» на исходные испущенные элементы. В терминологии оператора Окно, когда окно «открывается», это означает, что испускается новый Observable, и этот Observable начнёт испускать элементы, испускаемые исходным Observable. Когда окно «закрывается», это означает, что испускаемый Observable прекращает испускать элементы из исходного Observable и завершается уведомлением onCompleted для своих наблюдателей.
См. также
Информация для конкретного языка
RxClojure partition-all
RxClojure реализует этот оператор как partition-all:
partition-all открывает своё первое окно сразу. Он открывает новое окно, начиная с каждого step элемента из исходного Observable (например, если step равно 3, то он открывает новое окно, начиная с каждого третьего элемента). Он закрывает каждое окно, когда это окно испустило n элементов или если он получает уведомление onCompleted или onError из исходного Observable. Если step = n (по умолчанию, если вы опустите параметр step), то размер окна такой же, как и шаг, и будет взаимно однозначное соответствие между элементами, испущенными исходным Observable, и элементами, испущенными коллекцией Observable-окон. Если step < n, окна будут перекрываться на n − step элементов; если step > n, окна будут пропускать step − n элементов из исходного Observable между каждым окном.
RxCpp window window_with_time window_with_time_or_count
RxCpp реализует этот оператор как две разновидности window, две разновидности window_with_time, и как window_with_time_or_count:
window(count)
Эта разновидность window открывает своё первое окно сразу. Она закрывает текущее открытое окно и немедленно открывает новое, когда текущее окно испустило count элементов. Она также закроет текущее открытое окно, если получит уведомление onCompleted или onError от исходного Observable. Эта разновидность window испускает серию неперекрывающихся окон, чьи совокупные испускания соответствуют один к одному испусканиям исходного Observable.
window(count, skip)
Эта разновидность window открывает своё первое окно сразу. Она открывает новое окно, начиная с каждого skip элемента из исходного Observable (например, если skip равно 3, то она открывает новое окно, начиная с каждого третьего элемента). Она закрывает каждое окно, когда это окно испустило count элементов или если она получит уведомление onCompleted или onError от исходного Observable. Если skip = count, это ведёт себя так же, как window(source, count); если skip < count, это будет испускать окна, которые перекрываются на count − skip элементов; если skip > count, это будет испускать окна, которые пропускают skip − count элементов из исходного Observable между каждым окном.
window_with_time(period[, coordination])
![window_with_time(period[,coordination])](http://reactivex.io/documentation/operators/images/window_with_time5.png)
Эта разновидность window_with_time открывает своё первое окно сразу. Она закрывает текущее открытое окно и открывает другое каждые period времени (Duration, опционально вычисляемый заданным согласованием). Она также закроет текущее открытое окно, если получит уведомление onCompleted или onError от исходного Observable. Эта разновидность window_with_time испускает серию неперекрывающихся окон, чьи совокупные испускания соответствуют один к одному испусканиям исходного Observable.
window_with_time(period, skip[, coordination])
![window_with_time(period,skip[,coordination])](http://reactivex.io/documentation/operators/images/window_with_time7.png)
Эта разновидность window_with_time открывает своё первое окно сразу. Она закрывает текущее открытое окно через period единиц времени после его открытия, и открывает новое окно через skip единиц времени после открытия предыдущего окна (оба значения — Duration, опционально вычисляемые заданным согласованием). Она также закроет текущее открытое окно, если получит уведомление onCompleted или onError от исходного Observable. Эта разновидность window_with_time может испускать окна, которые перекрываются или имеют разрывы, в зависимости от того, является ли skip меньше или больше, чем period.
window_with_time_or_count(period, count[, coordination])
![window_with_time_or_count(period,count[,coordination])](http://reactivex.io/documentation/operators/images/window_with_time_or_count.png)
window_with_time_or_count открывает своё первое окно сразу. Она закрывает текущее открытое окно и открывает другое каждые period времени (опционально вычисляемые заданным согласованием) или когда текущее открытое окно испустило count элементов. Она также закроет текущее открытое окно, если получит уведомление onCompleted или onError от исходного Observable. window_with_time_or_count испускает серию неперекрывающихся окон, чьи совокупные испускания соответствуют один к одному испусканиям исходного Observable.
RxGroovy window
Существует несколько вариантов оператора Window в RxGroovy.
window(closingSelector)
Этот вариант оператора Window открывает первый блок немедленно. Он закрывает текущий блок и немедленно открывает новый каждый раз, когда наблюдается объект, испускаемый Observable, возвращаемым из closingSelector. Таким образом, этот вариант оператора Window испускает серию неперекрывающихся блоков, чьи коллективные испускания соответствуют один к одному испусканиям исходного Observable.
- Javadoc:
window(Func0)
window(windowOpenings, closingSelector)
Этот вариант оператора Window открывает блок всякий раз, когда он наблюдает за испусканием объекта Observable windowOpenings и в то же время вызывает closingSelector, чтобы сгенерировать Observable закрытия, связанный с этим блоком. Когда этот Observable закрытия испускает объект, window закрывает этот блок. Поскольку закрытие текущих блоков и открытие новых являются действиями, управляемыми независимыми Observable, этот вариант оператора Window может создавать блоки, которые перекрываются (дублируя элементы из исходного Observable) или которые оставляют пробелы (отбрасывая элементы из исходного Observable).
- Javadoc:
window(Observable,Func1)
window(count)
Этот вариант оператора Window открывает свой первый блок немедленно. Он закрывает текущий блок и немедленно открывает новый, когда текущий блок испустил count элементов. Также будет закрыт текущий блок, если он получит уведомление onCompleted или onError от исходного Observable. Этот вариант оператора Window испускает серию неперекрывающихся блоков, чьи коллективные испускания соответствуют один к одному испусканиям исходного Observable.
- Javadoc:
window(int)
window(count, skip)
Этот вариант оператора Window открывает свой первый блок немедленно. Он открывает новый блок, начиная с каждого skip элемента от исходного Observable (например, если skip равно 3, то он открывает новый блок, начиная с каждым третьим элементом). Он закрывает каждый блок, когда этот блок испустил count элементов или если он получает уведомление onCompleted или onError от исходного Observable. Если skip = count, тогда это ведет себя так же, как window(source, count); если skip < count, это будет испускать блоки, которые перекрываются на count − skip элементов; если skip > count, это будет испускать блоки, которые пропускают skip − count элементов из исходного Observable между каждым блоком.
- Javadoc:
window(int,int)
window(timespan, unit[, scheduler])
![window(timespan, unit[, scheduler])](http://reactivex.io/documentation/operators/images/window5.png)
Этот вариант оператора Window открывает свой первый блок немедленно. Он закрывает текущий блок и открывает другой через каждые timespan периодов времени (измеряемых в unit, и необязательно на определенном Scheduler). Также будет закрыт текущий блок, если он получит уведомление onCompleted или onError от исходного Observable. Этот вариант оператора Window испускает серию неперекрывающихся блоков, чьи коллективные испускания соответствуют один к одному испусканиям исходного Observable.
Если вы не укажете Scheduler, этот вариант оператора Window по умолчанию использует Scheduler computation для своего таймера.
- Javadoc:
window(long,TimeUnit) - Javadoc:
window(long,TimeUnit,Scheduler)
window(timespan, unit, count[, scheduler])
![window(timespan, unit, count[, scheduler])](http://reactivex.io/documentation/operators/images/window6.png)
Этот вариант оператора Window открывает свой первый блок немедленно. Он закрывает текущий блок и открывает другой через каждые timespan периодов времени (измеряемых в unit, и необязательно на определенном Scheduler) или когда текущий блок испустил count элементов. Также будет закрыт текущий блок, если он получит уведомление onCompleted или onError от исходного Observable. Этот вариант оператора Window испускает серию неперекрывающихся блоков, чьи коллективные испускания соответствуют один к одному испусканиям исходного Observable.
Если вы не укажете Scheduler, этот вариант оператора Window по умолчанию использует Scheduler computation для своего таймера.
- Javadoc:
window(long,TimeUnit,int) - Javadoc:
window(long,TimeUnit,int,Scheduler)
window(timespan, timeshift, unit[, scheduler])
![window(timespan, timeshift, unit[, scheduler])](http://reactivex.io/documentation/operators/images/window7.png)
Этот вариант оператора Window открывает свой первый блок немедленно, и после этого открывает новый блок через каждые timeshift периодов времени (измеряемых в unit, и необязательно на определенном Scheduler). Он закрывает текущий открытый блок после того, как прошло timespan периодов времени с момента его открытия. Также будет закрыт любой открытый блок, если он получит уведомление onCompleted или onError от исходного Observable. В зависимости от того, как вы настроите timespan и timeshift, блоки, полученные в результате этой операции, могут перекрываться или иметь пробелы.
Если вы не укажете Scheduler, этот вариант оператора Window по умолчанию использует Scheduler computation для своего таймера.
- Javadoc:
window(long,long,TimeUnit) - Javadoc:
window(long,long,TimeUnit,Scheduler)
Вы можете использовать оператор Window для реализации обратной связи (то есть, для работы с Observable, который может генерировать элементы слишком быстро для обработки их наблюдателем).
Window может уменьшить последовательность многих элементов до последовательности меньшего количества блоков-элементов, что делает их более управляемыми. Например, вы можете периодически, через равные промежутки времени, испускать блок элементов из импульсного Observable.
Пример кода
Observable<Observable<Integer>> burstyWindowed = bursty.window(500, TimeUnit.MILLISECONDS);
Или вы можете выбрать испускание нового блока элементов для каждых n элементов, испускаемых импульсным Observable.
Пример кода
Observable<Observable<Integer>> burstyWindowed = bursty.window(5);
RxJava 1․x window
Существует несколько разновидностей оператора Window в RxJava.
window(closingSelector)
Этот вариант оператора Window открывает свой первый интервал сразу. Он закрывает текущий интервал и немедленно открывает новый каждый раз, когда наблюдает за объектом, выпущенным Observable, возвращаемым из closingSelector. Таким образом, этот вариант оператора Window выпускает серию неперекрывающихся интервалов, чьи коллективные выходы соответствуют один к одному выходам исходного Observable.
- Javadoc:
window(Func0)
window(windowOpenings, closingSelector)
Этот вариант оператора Window открывает интервал всякий раз, когда наблюдает за тем, как Observable windowOpenings выпускает объект Opening и одновременно вызывает closingSelector для генерации закрывающего Observable, связанного с этим интервалом. Когда это закрывающее Observable выпускает объект, window закрывает этот интервал. Поскольку закрытие текущих интервалов и открытие новых являются операциями, регулируемыми независимыми Observable, этот вариант оператора Window может создавать интервалы, которые перекрываются (дублируя элементы из исходного Observable) или оставляют пробелы (отбрасывая элементы из исходного Observable).
- Javadoc:
window(Observable,Func1)
window(count)
Этот вариант оператора Window открывает свой первый интервал сразу. Он закрывает текущий интервал и немедленно открывает новый, когда текущий интервал выпустил count элементов. Также будет закрыт текущий интервал, если он получит уведомление onCompleted или onError от исходного Observable. Этот вариант оператора Window выпускает серию неперекрывающихся интервалов, чьи коллективные выходы соответствуют один к одному выходам исходного Observable.
- Javadoc:
window(int)
window(count, skip)
Этот вариант оператора Window открывает свой первый интервал сразу. Он открывает новый интервал с каждым skip элементом из исходного Observable (например, если skip равно 3, то он открывает новый интервал, начиная с каждым третьим элементом). Он закрывает каждый интервал, когда этот интервал выпустил count элементов или если он получит уведомление onCompleted или onError от исходного Observable. Если skip = count , то он работает так же, как window(source, count); если skip < count , то это выпустит интервалы, которые перекрываются на count − skip элементах; если skip > count , то это выпустит интервалы, отбрасывающие skip − count элементов из исходного Observable между каждым интервалом.
- Javadoc:
window(int,int)
window(timespan, unit[, scheduler])
Этот вариант оператора Window открывает свой первый интервал сразу. Он закрывает текущий интервал и открывает другой через каждый timespan период времени (измеренный в unit, и необязательно на конкретном Scheduler). Также будет закрыт текущий интервал, если он получит уведомление onCompleted или onError от исходного Observable. Этот вариант оператора Window выпускает серию неперекрывающихся интервалов, чьи коллективные выходы соответствуют один к одному выходам исходного Observable.
Если вы не укажете Scheduler, этот вариант оператора Window по умолчанию использует computation Scheduler для своего таймера.
- Javadoc:
window(long,TimeUnit) - Javadoc:
window(long,TimeUnit,Scheduler)
window(timespan, unit, count[, scheduler])
Этот вариант оператора Window открывает свой первый интервал сразу. Он закрывает текущий интервал и открывает другой через каждый timespan период времени (измеренный в unit, и необязательно на конкретном Scheduler) или когда текущий интервал выпустил count элементов. Также будет закрыт текущий интервал, если он получит уведомление onCompleted или onError от исходного Observable. Этот вариант оператора Window выпускает серию неперекрывающихся интервалов, чьи коллективные выходы соответствуют один к одному выходам исходного Observable.
Если вы не укажете Scheduler, этот вариант оператора Window по умолчанию использует computation Scheduler для своего таймера.
- Javadoc:
window(long,TimeUnit,int) - Javadoc:
window(long,TimeUnit,int,Scheduler)
window(timespan, timeshift, unit[, scheduler])
Этот вариант оператора Window открывает свой первый интервал сразу, а затем открывает новый интервал через каждый timeshift период времени (измеренный в unit, и необязательно на конкретном Scheduler). Он закрывает текущий интервал после того, как прошло timespan период времени с момента его открытия. Также будет закрыт любой открытый интервал, если он получит уведомление onCompleted или onError от исходного Observable. В зависимости от того, как вы установите timespan и timeshift, интервалы, полученные в результате этой операции, могут перекрываться или иметь пробелы.
Если вы не укажете Scheduler, этот вариант оператора Window по умолчанию использует computation Scheduler для своего таймера.
- Javadoc:
window(long,long,TimeUnit) - Javadoc:
window(long,long,TimeUnit,Scheduler)
Оператор Window можно использовать для реализации обратной связи (то есть для обработки Observable, который может производить элементы слишком быстро для их потребления наблюдателем).
Window может уменьшить последовательность из многих элементов до последовательности из меньшего количества интервалов-элементов, сделав их более управляемыми. Например, вы можете периодически выводить интервал элементов из «импульсного» Observable через регулярные промежутки времени.
Пример кода
Observable<Observable<Integer>> burstyWindowed = bursty.window(500, TimeUnit.MILLISECONDS);
Или вы можете выбрать вывод нового интервала элементов для каждых n элементов, выпущенных «импульсным» Observable.
Пример кода
Observable<Observable<Integer>> burstyWindowed = bursty.window(5);
RxJS window windowWithCount windowWithTime windowWithTimeOrCount
window(windowClosingSelector)
window(windowOpenings, windowClosingSelector)
window(windowBoundaries)
Этот вариант window принимает второй Observable в качестве параметра. Всякий раз, когда этот второй Observable испускает элемент, window закрывает текущее окно Observable (если таковое имеется) и открывает новое.
windowWithCount(count)
Этот вариант windowWithCount открывает свое первое окно немедленно. Он закрывает текущее открытое окно и немедленно открывает новое всякий раз, когда текущее окно испустило count элементов. Он также закроет текущее открытое окно, если получит уведомление onCompleted или onError от исходного Observable. Этот вариант windowWithCount испускает серию неперекрывающихся окон, чьи коллективные испускания соответствуют один к одному испусканиям исходного Observable.
windowWithCount(count, skip)
Этот вариант windowWithCount открывает свое первое окно немедленно. Он открывает новое окно, начиная с каждого skip элемента из исходного Observable (например, если skip равно 3, то он открывает новое окно, начиная с каждого третьего элемента). Он закрывает каждое окно, когда это окно испустило count элементов или если получит уведомление onCompleted или onError от исходного Observable. Если skip = count, то это ведет себя так же, как windowWithCount(count); если skip < count, это будет испускать окна, которые перекрываются на count − skip элементах; если skip > count, это будет испускать окна, отбрасывающие skip − count элементов из исходного Observable между каждым окном.
windowWithTime(timeSpan[,scheduler])
Этот вариант windowWithTime открывает свое первое окно немедленно. Он закрывает текущее открытое окно и открывает другое окно каждые timespan периоды времени (в миллисекундах, необязательно на определённом Планировщике). Он также закроет текущее открытое окно, если получит уведомление onCompleted или onError от исходного Observable. Этот вариант windowWithTime испускает серию неперекрывающихся окон, чьи коллективные испускания соответствуют один к одному испусканиям исходного Observable.
Если вы не укажете Планировщик, этот вариант windowWithTime по умолчанию использует timeout Планировщик для своего таймера.
windowWithTime(timeSpan,timeShift[,scheduler])
Этот вариант windowWithTime открывает свое первое окно немедленно, а затем открывает новое окно каждые timeshift миллисекунд (необязательно на определённом Планировщике). Он закрывает текущее открытое окно через timespan миллисекунд после его открытия. Он также закроет любое открытое окно, если получит уведомление onCompleted или onError от исходного Observable. В зависимости от того, как вы настроили timespan и timeshift, полученные окна могут перекрываться или иметь пробелы.
Если вы не укажете Планировщик, этот вариант windowWithTime по умолчанию использует timeout Планировщик для своего таймера.
windowWithTimeOrCount(timeSpan,count[,scheduler])
windowWithTimeOrCount открывает свое первое окно немедленно. Он закрывает текущее открытое окно и открывает другое каждые timespan миллисекунды (необязательно на определённом Планировщике) или когда текущее открытое окно испустило count элементов. Он также закроет текущее открытое окно, если получит уведомление onCompleted или onError от исходного Observable. windowWithTimeOrCount испускает серию неперекрывающихся окон, чьи коллективные испускания соответствуют один к одному испусканиям исходного Observable.
Если вы не укажете Планировщик, этот вариант windowWithTimeOrCount по умолчанию использует timeout Планировщик для своего таймера.
RxKotlin window
Существует несколько разновидностей Window в RxKotlin.
window(closingSelector)
Этот вариант window открывает свое первое окно немедленно. Он закрывает текущее открытое окно и немедленно открывает новое каждый раз, когда наблюдает за объектом, испущенным Observable, возвращаемым из closingSelector. Таким образом, этот вариант window испускает серию неперекрывающихся окон, чьи коллективные испускания соответствуют один к одному испусканиям исходного Observable.
window(windowOpenings, closingSelector)
Этот вариант window открывает окно всякий раз, когда наблюдает за испусканием windowOpenings Observable объекта Opening и одновременно вызывает closingSelector для генерации Observable закрытия, связанного с этим окном. Когда этот Observable закрытия испускает объект, window закрывает это окно. Поскольку закрытие текущих открытых окон и открытие новых окон являются операциями, регулируемыми независимыми Observable, этот вариант window может создавать окна, которые перекрываются (дублируя элементы из исходного Observable) или оставляют пробелы (удаляя элементы из исходного Observable).
window(count)
Этот вариант window открывает свое первое окно немедленно. Он закрывает текущее открытое окно и немедленно открывает новое, когда текущее окно испустило count элементов. Он также закроет текущее открытое окно, если получит уведомление onCompleted или onError от исходного Observable. Этот вариант window испускает серию неперекрывающихся окон, чьи коллективные испускания соответствуют один к одному испусканиям исходного Observable.
window(count, skip)
Этот вариант window открывает свое первое окно немедленно. Он открывает новое окно, начиная с каждого skip элемента из исходного Observable (например, если skip равно 3, то он открывает новое окно, начиная с каждого третьего элемента). Он закрывает каждое окно, когда это окно испустило count элементов или если получит уведомление onCompleted или onError от исходного Observable. Если skip = count, то это ведет себя так же, как window(source, count); если skip < count, это будет испускать окна, которые перекрываются на count − skip элементах; если skip > count, это будет испускать окна, отбрасывающие skip − count элементов из исходного Observable между каждым окном.
window(timespan, unit[, scheduler])
Этот вариант window открывает свое первое окно немедленно. Он закрывает текущее открытое окно и открывает другое окно каждые timespan периода времени (в unit, необязательно на определённом Scheduler). Он также закроет текущее открытое окно, если получит уведомление onCompleted или onError от исходного Observable. Этот вариант window испускает серию неперекрывающихся окон, чьи коллективные испускания соответствуют один к одному испусканиям исходного Observable.
Если вы не укажете Планировщик, этот вариант window по умолчанию использует computation Планировщик для своего таймера.
window(timespan, unit, count[, scheduler])
Этот вариант window открывает свое первое окно немедленно. Он закрывает текущее открытое окно и открывает другое окно каждые timespan периода времени (в unit, необязательно на определённом Scheduler) или когда текущее открытое окно испустило count элементов. Он также закроет текущее открытое окно, если получит уведомление onCompleted или onError от исходного Observable. Этот вариант window испускает серию неперекрывающихся окон, чьи коллективные испускания соответствуют один к одному испусканиям исходного Observable.
Если вы не укажете Планировщик, этот вариант window по умолчанию использует computation Планировщик для своего таймера.
window(timespan, timeshift, unit[, scheduler])
Этот вариант window открывает свое первое окно немедленно, а затем открывает новое окно каждые timeshift периода времени (в unit, необязательно на определённом Scheduler). Он закрывает текущее открытое окно через timespan период времени после его открытия. Он также закроет любое открытое окно, если получит уведомление onCompleted или onError от исходного Observable. В зависимости от того, как вы настроили timespan и timeshift, полученные окна могут перекрываться или иметь пробелы.
Если вы не укажете Планировщик, этот вариант window по умолчанию использует computation Планировщик для своего таймера.
RxNET Window
Существует несколько вариантов оператора Window в Rx.NET.
Window(windowClosingSelector)
Этот вариант оператора Window открывает свой первый интервал сразу и вызывает функцию windowClosingSelector, чтобы получить второй Observable. Всякий раз, когда этот второй Observable испускает объект TWindowClosing, Window закрывает текущий интервал и немедленно открывает новый. Он повторяет этот процесс, пока один из Observable не завершит свою работу. Таким образом, этот вариант оператора Window испускает серию непересекающихся интервалов, чьи коллективные испускания соответствуют один к одному испусканиям исходного Observable, до тех пор, пока Observable выбора закрытия не завершит работу.
Window(count)
Этот вариант оператора Window открывает свой первый интервал сразу. Он закрывает текущий интервал и немедленно открывает новый всякий раз, когда текущий интервал испустил count элементов. Он также закроет текущий интервал, если получит уведомление onCompleted или onError от исходного Observable. Этот вариант оператора Window испускает серию непересекающихся интервалов, чьи коллективные испускания соответствуют один к одному испусканиям исходного Observable.
Window(timeSpan[,scheduler])
Этот вариант оператора Window открывает свой первый интервал сразу. Он закрывает текущий интервал и открывает другой через каждый timespan период времени (в виде объекта TimeSpan, и, необязательно, на определённом IScheduler). Он также закроет текущий интервал, если получит уведомление onCompleted или onError от исходного Observable. Этот вариант оператора Window испускает серию непересекающихся интервалов, чьи коллективные испускания соответствуют один к одному испусканиям исходного Observable.
Window(count,skip)
Этот вариант оператора Window открывает свой первый интервал сразу. Он открывает новый интервал, начиная с каждого skip элемента из исходного Observable (например, если skip равно 3, то он открывает новый интервал, начиная с каждого третьего элемента). Он закрывает каждый интервал, когда этот интервал испустил count элементов или если получит уведомление onCompleted или onError от исходного Observable. Если skip = count, то это ведёт себя так же, как Window(source, count); если skip < count, это будет испускать интервалы, перекрывающиеся на count − skip элементах; если skip > count, это будет испускать интервалы, пропускающие skip − count элементов из исходного Observable между каждым интервалом.
Window(windowOpenings,windowClosingSelector)
Этот вариант оператора Window открывает интервал всякий раз, когда наблюдаемый им windowOpenings Observable испускает объект TWindowOpening и одновременно вызывает функцию windowClosingSelector, передавая ей этот объект TWindowOpening, чтобы сгенерировать Observable закрытия, связанный с этим интервалом. Когда этот Observable закрытия испускает объект TWindowClosing, Window закрывает ассоциированный интервал. Поскольку закрытие текущих интервалов и открытие новых интервалов являются действиями, регулируемыми независимыми Observable, этот вариант оператора Window может создавать интервалы, которые перекрываются (дублируя элементы из исходного Observable) или которые оставляют пробелы (исключая элементы из исходного Observable).
Window(timeSpan,count[,scheduler])
Этот вариант оператора Window открывает свой первый интервал сразу. Он закрывает текущий интервал и открывает другой через каждый timeSpan период времени (в виде объекта TimeSpan, и, необязательно, на определённом IScheduler) или когда текущий интервал испустил count элементов. Он также закроет текущий интервал, если получит уведомление onCompleted или onError от исходного Observable. Этот вариант оператора Window испускает серию непересекающихся интервалов, чьи коллективные испускания соответствуют один к одному испусканиям исходного Observable.
Window(timeSpan,timeShift[,scheduler])
Этот вариант оператора Window открывает свой первый интервал сразу, а затем открывает новый интервал через каждый timeShift период времени (в виде объекта TimeSpan, и, необязательно, на определённом IScheduler). Он закрывает текущий интервал через timeSpan период времени после его открытия. Он также закроет любой текущий интервал, если получит уведомление onCompleted или onError от исходного Observable. В зависимости от того, как вы настроили timeSpan и timeShift, полученные интервалы могут перекрываться или содержать пробелы.
RxPY window window_with_count window_with_time window_with_time_or_count
RxPY реализует этот оператор с несколькими вариантами четырёх различных функций.
window(window_closing_selector)
Этот вариант window открывает первое окно немедленно и вызывает функцию closing_selector для получения второго Observable. Когда этот второй Observable испускает элемент, window закрывает текущее открытое окно, немедленно открывает новое и снова вызывает функцию closing_selector для получения нового Observable. Этот процесс повторяется до тех пор, пока исходный Observable не завершится. Таким образом, этот вариант window испускает серию непересекающихся окон, чьи совокупные испускания соответствуют испусканиям исходного Observable один к одному.
window(window_openings,window_closing_selector)
Этот вариант window открывает окно всякий раз, когда он наблюдает за испусканием элемента Observable window_openings, и в то же время вызывает closing_selector для генерации закрывающего Observable, связанного с этим окном. Когда этот закрывающий Observable испускает объект, window закрывает это окно. Поскольку закрытие текущих открытых окон и открытие новых окон являются действиями, регулируемыми независимыми Observable, этот вариант window может создавать перекрывающиеся окна (дублируя элементы из исходного Observable) или оставляющие пробелы (отбрасывая элементы из исходного Observable).
window(window_openings)
Этот вариант window принимает второй Observable в качестве параметра. Всякий раз, когда этот второй Observable испускает элемент, window закрывает текущее окно Observable (если таковое имеется) и открывает новое.
window_with_count(count)
Этот вариант window_with_count открывает первое окно немедленно. Он закрывает текущее открытое окно и немедленно открывает новое всякий раз, когда текущее окно испустило count элементов. Он также закроет текущее открытое окно, если получит уведомление onCompleted или onError от исходного Observable. Этот вариант window_with_count испускает серию непересекающихся окон, чьи совокупные испускания соответствуют испусканиям исходного Observable один к одному.
window_with_count(count,skip)
Этот вариант window_with_count открывает первое окно немедленно. Он открывает новое окно, начиная с каждого элемента skip из исходного Observable (например, если skip равно 3, то открывает новое окно, начиная с каждого третьего элемента). Он закрывает каждое окно, когда это окно испустило count элементов или если получает уведомление onCompleted или onError от исходного Observable. Если skip = count, то он ведет себя так же, как window_with_count(count); если skip < count, это будет испускать окна, которые перекрываются на count − skip элементах; если skip > count, это будет испускать окна, которые пропускают skip − count элементов из исходного Observable между каждым окном.
window_with_time(timespan[,scheduler])
window_with_time(timespan,timeshift[,scheduler])
Этот вариант window_with_time открывает первое окно немедленно. Он закрывает текущее открытое окно и открывает новое через каждые timespan миллисекунд (опционально, измеряя на определенном Scheduler). Он также закроет текущее открытое окно, если получит уведомление onCompleted или onError от исходного Observable. Этот вариант window_with_time испускает серию непересекающихся окон, чьи совокупные испускания соответствуют испусканиям исходного Observable один к одному.
Если вы не укажете Scheduler, этот вариант window_with_time использует Scheduler timeout для своего таймера по умолчанию.
window_with_time_or_count(timespan,count[,scheduler])
window_with_time_or_count открывает первое окно немедленно. Он закрывает текущее открытое окно и открывает другое через каждые timespan миллисекунд (опционально, измеряя на определенном Scheduler) или когда текущее открытое окно испустило count элементов. Он также закроет текущее открытое окно, если получит уведомление onCompleted или onError от исходного Observable. window_with_time_or_count испускает серию непересекающихся окон, чьи совокупные испускания соответствуют испусканиям исходного Observable один к одному.
Если вы не укажете Scheduler, этот вариант window_with_time_or_count использует Scheduler timeout для своего таймера по умолчанию.
Rxrb window_with_count
window_with_count(count,skip)
Rx.rb реализует этот оператор как window_with_count. Он открывает первое окно немедленно. Затем он открывает новое окно, начиная с каждого skip элемента из исходного Observable (например, если skip равно 3, то открывает новое окно, начиная с каждого третьего элемента). Он закрывает каждое окно, когда это окно испустило count элементов или если получает уведомление onCompleted или onError от исходного Observable. Если skip = count, то существует взаимно однозначное соответствие между элементами, испускаемыми исходным Observable, и элементами, испускаемыми окнами Observable; если skip < count, окна будут перекрываться на count − skip элементах; если skip > count, окна будут пропускать skip − count элементов из исходного Observable между каждым окном.
RxScala sliding tumbling
RxScala реализует этот оператор как sliding (создает окна, которые могут перекрываться или иметь разрывы) и tumbling (создает окна, чьи коллективные выдачи соответствуют выдачам исходного Observable один к одному).
sliding(timespan,timeshift,count[,scheduler])
Этот вариант sliding открывает первое окно немедленно, а затем открывает новое окно каждые timeshift единиц времени (в виде объекта Duration, и необязательно на определенном Scheduler). Он закрывает текущее открытое окно после того, как прошло timespan единиц времени с момента открытия этого окна или после того, как на этом окне было выпущено count элементов. Он также закроет любое открытое окно, если получит уведомление onCompleted или onError от исходного Observable.
sliding(timespan,timeshift[,scheduler])
Этот вариант sliding открывает первое окно немедленно, а затем открывает новое окно каждые timeshift единиц времени (в виде объекта Duration, и необязательно на определенном Scheduler). Он закрывает текущее открытое окно после того, как прошло timespan единиц времени с момента его открытия. Он также закроет любое открытое окно, если получит уведомление onCompleted или onError от исходного Observable.
sliding(count,skip)
Этот вариант sliding открывает первое окно немедленно. Он открывает новое окно, начиная с каждого skip элемента из исходного Observable (например, если skip равно 3, то он открывает новое окно, начиная с каждым третьим элементом). Он закрывает каждое окно, когда это окно выпустило count элементов или если получит уведомление onCompleted или onError от исходного Observable. Если skip = count, то это ведет себя так же, как tumbling(count); если skip < count, это будет генерировать окна, которые перекрываются на count − skip элементами; если skip > count, это будет генерировать окна, пропускающие skip − count элементов из исходного Observable между каждым окном.
sliding(openings,closings)
Этот вариант sliding открывает окно всякий раз, когда он наблюдает за openings Observable, испускающим объект Opening, и одновременно вызывает closings для генерации закрывающего Observable, связанного с этим окном. Когда этот закрывающий Observable испускает элемент, sliding закрывает это окно.
tumbling(timespan,count[,scheduler])
Этот вариант tumbling открывает первое окно немедленно. Он закрывает текущее открытое окно и открывает другое окно каждые timespan единиц времени (объект Duration, необязательно измеренный на определенном Scheduler) или всякий раз, когда текущее открытое окно выпустило count элементов. Он также закроет текущее открытое окно, если получит уведомление onCompleted или onError от исходного Observable.
tumbling(timespan[,scheduler])
Этот вариант tumbling открывает первое окно немедленно. Он закрывает текущее открытое окно и открывает другое окно каждые timespan единиц времени (объект Duration, необязательно измеренный на определенном scheduler). Он также закроет текущее открытое окно, если получит уведомление onCompleted или onError от исходного Observable.
tumbling(count)
Этот вариант tumbling открывает первое окно немедленно. Он закрывает текущее открытое окно и немедленно открывает новое, когда текущее окно выпустило count элементов. Он также закроет текущее открытое окно, если получит уведомление onCompleted или onError от исходного Observable.
tumbling(boundary)
Этот вариант tumbling принимает второй Observable в качестве параметра. Всякий раз, когда этот второй Observable испускает элемент, tumbling закрывает текущее окно Observable (если таковое имеется) и открывает новое.
© ReactiveX contributors
Licensed under the Apache License 2.0.
http://reactivex.io/documentation/operators/window.html
