Window 與 Buffer 類似，但它不是發射來自來源 Observable 的項目包，而是發射 Observables，每個 Observable 發射來自來源 Observable 的項目子集，然後以 onCompleted 通知終止。
與 Buffer 類似，Window 有許多變體，每個變體都有其將原始 Observable 細分為最終發射的 Observable 的方式，每個 Observable 都包含一個原始發射項目的「視窗」。在 Window 操作符的術語中，當視窗「開啟」時，表示會發射新的 Observable，並且該 Observable 將開始發射來源 Observable 發射的項目。當視窗「關閉」時，表示發射的 Observable 停止發射來自來源 Observable 的項目，並向其觀察者發送 onCompleted 通知。
RxClojure 將此操作符實現為 partition-all
partition-all 會立即開啟第一個視窗。它會從來源 Observable 的每個 step 項目開始開啟一個新視窗（例如，如果 step 為 3，則會從每個第三個項目開始開啟一個新視窗）。當該視窗已發射 n 個項目，或從來源 Observable 收到 onCompleted 或 onError 通知時，它會關閉每個視窗。如果 step = n（如果您省略 step 參數，則為預設值），則視窗大小與步進大小相同，並且來源 Observable 發射的項目與視窗 Observables 的集合發射的項目之間存在一對一的對應關係。如果 step < n，則視窗將重疊 n − step 個項目；如果 step > n，則視窗將在每個視窗之間從來源 Observable 丟棄 step − n 個項目。
RxCpp 將此操作符實現為 window 的兩個變體、window_with_time 的兩個變體，以及 window_with_time_or_count
ReactiveXwindow(count)
此變體的 window 會立即開啟其第一個視窗。每當目前視窗發射 count 個項目時，它就會關閉目前開啟的視窗，並立即開啟一個新視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉目前開啟的視窗。此變體的 window 會發射一系列非重疊視窗，其整體發射與來源 Observable 的發射一對一對應。
window(count, skip)
此變體的 window 會立即開啟其第一個視窗。它會從來源 Observable 的每個 skip 項目開始開啟一個新視窗（例如，如果 skip 為 3，則會從每個第三個項目開始開啟一個新視窗）。當該視窗已發射 count 個項目，或從來源 Observable 收到 onCompleted 或 onError 通知時，它會關閉每個視窗。如果 skip = count，則此行為與 window(source, count) 相同；如果 skip < count，則會發射重疊 count − skip 個項目的視窗；如果 skip > count，則會發射在每個視窗之間從來源 Observable 丟棄 skip − count 個項目的視窗。
window_with_time(period[, coordination])![window_with_time(period[,coordination])](images/window_with_time5.png)
此變體的 window_with_time 會立即開啟其第一個視窗。它會關閉目前開啟的視窗，並每隔 period 時間（持續時間，可選擇由給定的協調計算）開啟另一個視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉目前開啟的視窗。此變體的 window_with_time 會發射一系列非重疊視窗，其整體發射與來源 Observable 的發射一對一對應。
window_with_time(period, skip[, coordination])![window_with_time(period,skip[,coordination])](images/window_with_time7.png)
此變體的 window_with_time 會立即開啟其第一個視窗。它會在自開啟以來經過 period 時間後關閉目前開啟的視窗，並在自先前視窗開啟以來經過 skip 時間後開啟一個新視窗（兩個時間都是持續時間，可選擇由給定的協調計算）。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉目前開啟的視窗。此變體的 window_with_time 可能會發射重疊或有間隙的視窗，具體取決於 skip 是小於還是大於 period。
window_with_time_or_count(period, count[, coordination])![window_with_time_or_count(period,count[,coordination])](images/window_with_time_or_count.png)
window_with_time_or_count 會立即開啟其第一個視窗。它會關閉目前開啟的視窗，並每隔 period 時間（可選擇由給定的協調計算）或每當目前開啟的視窗發射 count 個項目時開啟另一個視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉目前開啟的視窗。window_with_time_or_count 會發射一系列非重疊視窗，其整體發射與來源 Observable 的發射一對一對應。
在 RxGroovy 中，Window 有多種變體。
window(closingSelector)
此變體的 window 會立即開啟其第一個視窗。每當它觀察到 closingSelector 返回的 Observable 發射的物件時，它就會關閉目前開啟的視窗，並立即開啟一個新視窗。這樣，此變體的 window 會發射一系列非重疊視窗，其整體發射與來源 Observable 的發射一對一對應。
window(Func0)window(windowOpenings, closingSelector)
此變體的 window 會在它觀察到 windowOpenings Observable 發射 Opening 物件時開啟一個視窗，同時呼叫 closingSelector 以產生與該視窗關聯的關閉 Observable。當該關閉 Observable 發射一個物件時，window 會關閉該視窗。由於目前開啟視窗的關閉和新視窗的開啟是由獨立 Observables 調節的活動，因此此變體的 window 可能會建立重疊（複製來自來源 Observable 的項目）或留下間隙（捨棄來自來源 Observable 的項目）的視窗。
window(Observable,Func1)window(count)
此變體的 window 會立即開啟其第一個視窗。每當目前視窗發射 count 個項目時，它就會關閉目前開啟的視窗，並立即開啟一個新視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉目前開啟的視窗。此變體的 window 會發射一系列非重疊視窗，其整體發射與來源 Observable 的發射一對一對應。
window(int)window(count, skip)
此變體的 window 會立即開啟其第一個視窗。它會從來源 Observable 的每個 skip 項目開始開啟一個新視窗（例如，如果 skip 為 3，則會從每個第三個項目開始開啟一個新視窗）。當該視窗已發射 count 個項目，或從來源 Observable 收到 onCompleted 或 onError 通知時，它會關閉每個視窗。如果 skip = count，則此行為與 window(source, count) 相同；如果 skip < count，則會發射重疊 count − skip 個項目的視窗；如果 skip > count，則會發射在每個視窗之間從來源 Observable 丟棄 skip − count 個項目的視窗。
window(int,int)window(timespan, unit[, scheduler])![window(timespan, unit[, scheduler])](images/window5.png)
此變體的 window 會立即開啟其第一個視窗。它會關閉目前開啟的視窗，並每隔 timespan 時間（以 unit 為單位測量，並且可選擇在特定的 Scheduler 上）開啟另一個視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉目前開啟的視窗。此變體的 window 會發射一系列非重疊視窗，其整體發射與來源 Observable 的發射一對一對應。
如果您未指定 Scheduler，則此變體的 window 預設會將 computation Scheduler 用於其計時器。
window(long,TimeUnit)window(long,TimeUnit,Scheduler)window(timespan, unit, count[, scheduler])![window(timespan, unit, count[, scheduler])](images/window6.png)
此變體的 window 會立即開啟其第一個視窗。它會關閉目前開啟的視窗，並每隔 timespan 時間（以 unit 為單位測量，並且可選擇在特定的 Scheduler 上）或每當目前開啟的視窗發射 count 個項目時開啟另一個視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉目前開啟的視窗。此變體的 window 會發射一系列非重疊視窗，其整體發射與來源 Observable 的發射一對一對應。
如果您未指定 Scheduler，則此變體的 window 預設會將 computation Scheduler 用於其計時器。
window(long,TimeUnit,int)window(long,TimeUnit,int,Scheduler)window(timespan, timeshift, unit[, scheduler])![window(timespan, timeshift, unit[, scheduler])](images/window7.png)
此變體的 window 會立即開啟其第一個視窗，然後每隔 timeshift 時間（以 unit 為單位測量，並且可選擇在特定的 Scheduler 上）開啟一個新視窗。它會在自開啟以來經過 timespan 時間後關閉目前開啟的視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉任何目前開啟的視窗。根據您設定 timespan 和 timeshift 的方式，此操作產生的視窗可能會重疊或可能有間隙。
如果您未指定 Scheduler，則此變體的 window 預設會將 computation Scheduler 用於其計時器。
window(long,long,TimeUnit)window(long,long,TimeUnit,Scheduler)您可以使用 Window 運算子來實作背壓（也就是說，處理一個 Observable 可能產生項目速度太快，導致觀察者來不及消耗的情況）。
Window 可以將大量的項目序列縮減為較少的項目視窗序列，使其更易於管理。例如，您可以定期地，以固定的時間間隔，從一個爆發性的 Observable 發射項目視窗。
Observable<Observable<Integer>> burstyWindowed = bursty.window(500, TimeUnit.MILLISECONDS);
或者，您可以選擇在爆發性的 Observable 每發射 n 個項目時，發射一個新的項目視窗。
Observable<Observable<Integer>> burstyWindowed = bursty.window(5);
在 RxJava 中，Window 有幾種不同的變體。
window(closingSelector)
此變體的 window 會立即開啟其第一個視窗。每當它觀察到 closingSelector 返回的 Observable 發射的物件時，它就會關閉目前開啟的視窗，並立即開啟一個新視窗。這樣，此變體的 window 會發射一系列非重疊視窗，其整體發射與來源 Observable 的發射一對一對應。
window(Func0)window(windowOpenings, closingSelector)
此變體的 window 會在它觀察到 windowOpenings Observable 發射 Opening 物件時開啟一個視窗，同時呼叫 closingSelector 以產生與該視窗關聯的關閉 Observable。當該關閉 Observable 發射一個物件時，window 會關閉該視窗。由於目前開啟視窗的關閉和新視窗的開啟是由獨立 Observables 調節的活動，因此此變體的 window 可能會建立重疊（複製來自來源 Observable 的項目）或留下間隙（捨棄來自來源 Observable 的項目）的視窗。
window(Observable,Func1)window(count)
此變體的 window 會立即開啟其第一個視窗。每當目前視窗發射 count 個項目時，它就會關閉目前開啟的視窗，並立即開啟一個新視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉目前開啟的視窗。此變體的 window 會發射一系列非重疊視窗，其整體發射與來源 Observable 的發射一對一對應。
window(int)window(count, skip)
此變體的 window 會立即開啟其第一個視窗。它會從來源 Observable 的每個 skip 項目開始開啟一個新視窗（例如，如果 skip 為 3，則會從每個第三個項目開始開啟一個新視窗）。當該視窗已發射 count 個項目，或從來源 Observable 收到 onCompleted 或 onError 通知時，它會關閉每個視窗。如果 skip = count，則此行為與 window(source, count) 相同；如果 skip < count，則會發射重疊 count − skip 個項目的視窗；如果 skip > count，則會發射在每個視窗之間從來源 Observable 丟棄 skip − count 個項目的視窗。
window(int,int)window(timespan, unit[, scheduler])
此變體的 window 會立即開啟其第一個視窗。它會關閉目前開啟的視窗，並每隔 timespan 時間（以 unit 為單位測量，並且可選擇在特定的 Scheduler 上）開啟另一個視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉目前開啟的視窗。此變體的 window 會發射一系列非重疊視窗，其整體發射與來源 Observable 的發射一對一對應。
如果您未指定 Scheduler，則此變體的 window 預設會將 computation Scheduler 用於其計時器。
window(long,TimeUnit)window(long,TimeUnit,Scheduler)window(timespan, unit, count[, scheduler])
此變體的 window 會立即開啟其第一個視窗。它會關閉目前開啟的視窗，並每隔 timespan 時間（以 unit 為單位測量，並且可選擇在特定的 Scheduler 上）或每當目前開啟的視窗發射 count 個項目時開啟另一個視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉目前開啟的視窗。此變體的 window 會發射一系列非重疊視窗，其整體發射與來源 Observable 的發射一對一對應。
如果您未指定 Scheduler，則此變體的 window 預設會將 computation Scheduler 用於其計時器。
window(long,TimeUnit,int)window(long,TimeUnit,int,Scheduler)window(timespan, timeshift, unit[, scheduler])
此變體的 window 會立即開啟其第一個視窗，然後每隔 timeshift 時間（以 unit 為單位測量，並且可選擇在特定的 Scheduler 上）開啟一個新視窗。它會在自開啟以來經過 timespan 時間後關閉目前開啟的視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉任何目前開啟的視窗。根據您設定 timespan 和 timeshift 的方式，此操作產生的視窗可能會重疊或可能有間隙。
如果您未指定 Scheduler，則此變體的 window 預設會將 computation Scheduler 用於其計時器。
window(long,long,TimeUnit)window(long,long,TimeUnit,Scheduler)您可以使用 Window 運算子來實作背壓（也就是說，處理一個 Observable 可能產生項目速度太快，導致觀察者來不及消耗的情況）。
Window 可以將大量的項目序列縮減為較少的項目視窗序列，使其更易於管理。例如，您可以定期地，以固定的時間間隔，從一個爆發性的 Observable 發射項目視窗。
Observable<Observable<Integer>> burstyWindowed = bursty.window(500, TimeUnit.MILLISECONDS);
或者，您可以選擇在爆發性的 Observable 每發射 n 個項目時，發射一個新的項目視窗。
Observable<Observable<Integer>> burstyWindowed = bursty.window(5);
window(windowClosingSelector)
window(windowOpenings, windowClosingSelector)
window(windowBoundaries)
這個 window 的變體接受第二個 Observable 作為參數。每當第二個 Observable 發射一個項目時，window 就會關閉當前的 Observable 視窗（如果有的話），並開啟一個新的視窗。
windowWithCount(count)
這個 windowWithCount 的變體會立即開啟第一個視窗。每當目前的視窗發射了 count 個項目時，它就會關閉當前開啟的視窗，並立即開啟一個新的視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，它也會關閉目前開啟的視窗。這個 windowWithCount 的變體會發射一系列不重疊的視窗，這些視窗的總發射量與來源 Observable 的發射量一一對應。
windowWithCount(count, skip)
這個 windowWithCount 的變體會立即開啟第一個視窗。它會從來源 Observable 每隔 skip 個項目開啟一個新的視窗（例如，如果 skip 是 3，那麼它會從每第三個項目開始開啟一個新的視窗）。當該視窗發射了 count 個項目，或者如果它從來源 Observable 收到 onCompleted 或 onError 通知時，它會關閉每個視窗。如果 skip = count，則其行為與 windowWithCount(count) 相同；如果 skip < count，則會發射重疊 count − skip 個項目的視窗；如果 skip > count，則會在每個視窗之間丟棄來源 Observable 的 skip − count 個項目。
windowWithTime(timeSpan[,scheduler])
這個 windowWithTime 的變體會立即開啟第一個視窗。它會每隔 timespan 時間段（以毫秒為單位，可以選擇在特定的 排程器 上測量）關閉當前開啟的視窗並開啟另一個視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，它也會關閉目前開啟的視窗。這個 windowWithTime 的變體會發射一系列不重疊的視窗，這些視窗的總發射量與來源 Observable 的發射量一一對應。
如果您沒有指定排程器，則這個 windowWithTime 的變體預設會使用 timeout 排程器作為其計時器。
windowWithTime(timeSpan, timeShift[,scheduler])
這個 windowWithTime 的變體會立即開啟第一個視窗，然後每隔 timeshift 毫秒（可以選擇在特定的 排程器 上測量）開啟一個新的視窗。它會在自該視窗開啟以來經過 timespan 毫秒後關閉目前開啟的視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，它也會關閉任何目前開啟的視窗。根據您設定 timespan 和 timeshift 的方式，由此操作產生的視窗可能會重疊或有間隙。
如果您沒有指定排程器，則這個 windowWithTime 的變體預設會使用 timeout 排程器作為其計時器。
windowWithTimeOrCount(timeSpan, count[,scheduler])
windowWithTimeOrCount 會立即開啟第一個視窗。它會每隔 timespan 毫秒（可以選擇在特定的 排程器 上測量）或當前開啟的視窗發射了 count 個項目時，關閉當前開啟的視窗並開啟另一個視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，它也會關閉目前開啟的視窗。windowWithTimeOrCount 會發射一系列不重疊的視窗，這些視窗的總發射量與來源 Observable 的發射量一一對應。
如果您沒有指定排程器，則這個 windowWithTimeOrCount 的變體預設會使用 timeout 排程器作為其計時器。
在 RxKotlin 中，Window 有幾種不同的變體。
window(closingSelector)
此變體的 window 會立即開啟其第一個視窗。每當它觀察到 closingSelector 返回的 Observable 發射的物件時，它就會關閉目前開啟的視窗，並立即開啟一個新視窗。這樣，此變體的 window 會發射一系列非重疊視窗，其整體發射與來源 Observable 的發射一對一對應。
window(windowOpenings, closingSelector)
此變體的 window 會在它觀察到 windowOpenings Observable 發射 Opening 物件時開啟一個視窗，同時呼叫 closingSelector 以產生與該視窗關聯的關閉 Observable。當該關閉 Observable 發射一個物件時，window 會關閉該視窗。由於目前開啟視窗的關閉和新視窗的開啟是由獨立 Observables 調節的活動，因此此變體的 window 可能會建立重疊（複製來自來源 Observable 的項目）或留下間隙（捨棄來自來源 Observable 的項目）的視窗。
window(count)
此變體的 window 會立即開啟其第一個視窗。每當目前視窗發射 count 個項目時，它就會關閉目前開啟的視窗，並立即開啟一個新視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉目前開啟的視窗。此變體的 window 會發射一系列非重疊視窗，其整體發射與來源 Observable 的發射一對一對應。
window(count, skip)
此變體的 window 會立即開啟其第一個視窗。它會從來源 Observable 的每個 skip 項目開始開啟一個新視窗（例如，如果 skip 為 3，則會從每個第三個項目開始開啟一個新視窗）。當該視窗已發射 count 個項目，或從來源 Observable 收到 onCompleted 或 onError 通知時，它會關閉每個視窗。如果 skip = count，則此行為與 window(source, count) 相同；如果 skip < count，則會發射重疊 count − skip 個項目的視窗；如果 skip > count，則會發射在每個視窗之間從來源 Observable 丟棄 skip − count 個項目的視窗。
window(timespan, unit[, scheduler])
此變體的 window 會立即開啟其第一個視窗。它會關閉目前開啟的視窗，並每隔 timespan 時間（以 unit 為單位測量，並且可選擇在特定的 Scheduler 上）開啟另一個視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉目前開啟的視窗。此變體的 window 會發射一系列非重疊視窗，其整體發射與來源 Observable 的發射一對一對應。
如果您未指定 Scheduler，則此變體的 window 預設會將 computation Scheduler 用於其計時器。
window(timespan, unit, count[, scheduler])
此變體的 window 會立即開啟其第一個視窗。它會關閉目前開啟的視窗，並每隔 timespan 時間（以 unit 為單位測量，並且可選擇在特定的 Scheduler 上）或每當目前開啟的視窗發射 count 個項目時開啟另一個視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉目前開啟的視窗。此變體的 window 會發射一系列非重疊視窗，其整體發射與來源 Observable 的發射一對一對應。
如果您未指定 Scheduler，則此變體的 window 預設會將 computation Scheduler 用於其計時器。
window(timespan, timeshift, unit[, scheduler])
此變體的 window 會立即開啟其第一個視窗，然後每隔 timeshift 時間（以 unit 為單位測量，並且可選擇在特定的 Scheduler 上）開啟一個新視窗。它會在自開啟以來經過 timespan 時間後關閉目前開啟的視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉任何目前開啟的視窗。根據您設定 timespan 和 timeshift 的方式，此操作產生的視窗可能會重疊或可能有間隙。
如果您未指定 Scheduler，則此變體的 window 預設會將 computation Scheduler 用於其計時器。
在 Rx.NET 中，Window 運算子有幾種不同的變體。
Window(windowClosingSelector)
這個 Window 的變體會立即開啟第一個視窗，並呼叫 windowClosingSelector 函數以取得第二個 Observable。每當這個第二個 Observable 發射一個 TWindowClosing 物件時，Window 就會關閉目前開啟的視窗，並立即開啟一個新的視窗。它會重複這個過程，直到任一個 Observable 終止。透過這種方式，這個 Window 的變體會發射一系列不重疊的視窗，這些視窗的總發射量與來源 Observable 的發射量一一對應，直到關閉選擇器 Observable 終止。
Window(count)
這個 Window 的變體會立即開啟第一個視窗。每當目前的視窗發射了 count 個項目時，它就會關閉當前開啟的視窗，並立即開啟一個新的視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，它也會關閉目前開啟的視窗。這個 Window 的變體會發射一系列不重疊的視窗，這些視窗的總發射量與來源 Observable 的發射量一一對應。
Window(timeSpan[,scheduler])
這個 Window 的變體會立即開啟第一個視窗。它會每隔 timespan 時間段（以 TimeSpan 物件的形式，並且可以選擇在特定的 IScheduler 上測量）關閉當前開啟的視窗並開啟另一個視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，它也會關閉目前開啟的視窗。這個 Window 的變體會發射一系列不重疊的視窗，這些視窗的總發射量與來源 Observable 的發射量一一對應。
Window(count, skip)
這個 Window 的變體會立即開啟第一個視窗。它會從來源 Observable 每隔 skip 個項目開啟一個新的視窗（例如，如果 skip 是 3，那麼它會從每第三個項目開始開啟一個新的視窗）。當該視窗發射了 count 個項目，或者如果它從來源 Observable 收到 onCompleted 或 onError 通知時，它會關閉每個視窗。如果 skip = count，則其行為與 Window(source, count) 相同；如果 skip < count，則會發射重疊 count − skip 個項目的視窗；如果 skip > count，則會在每個視窗之間丟棄來源 Observable 的 skip − count 個項目。
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 個項目時，關閉當前開啟的視窗並開啟另一個視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，它也會關閉目前開啟的視窗。這個 window 的變體會發射一系列不重疊的視窗，這些視窗的總發射量與來源 Observable 的發射量一一對應。
Window(timeSpan, timeShift[,scheduler])
這個 Window 的變體會立即開啟第一個視窗，然後每隔 timeShift 時間段（以 TimeSpan 物件的形式，並且可以選擇在特定的 IScheduler 上測量）開啟一個新的視窗。它會在自該視窗開啟以來經過 timeSpan 時間段後關閉目前開啟的視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，它也會關閉任何目前開啟的視窗。根據您設定 timeSpan 和 timeShift 的方式，由此操作產生的視窗可能會重疊或有間隙。
RxPY 使用四種不同函數的幾種變體實作此運算子。
window(window_closing_selector)
這個 window 的變體會立即開啟第一個視窗，並呼叫 closing_selector 函數以取得第二個 Observable。當這個第二個 Observable 發射一個項目時，window 就會關閉目前開啟的視窗，立即開啟一個新的視窗，並再次呼叫 closing_selector 函數以取得一個新的 Observable。它會重複這個過程，直到來源 Observable 終止。透過這種方式，這個 window 的變體會發射一系列不重疊的視窗，這些視窗的總發射量與來源 Observable 的發射量一一對應。
window(window_openings, window_closing_selector)
這個 window 的變體會在觀察到 window_openings Observable 發射一個項目時開啟一個視窗，同時呼叫 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 個項目時，它就會關閉當前開啟的視窗，並立即開啟一個新的視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，它也會關閉目前開啟的視窗。這個 window_with_count 的變體會發射一系列不重疊的視窗，這些視窗的總發射量與來源 Observable 的發射量一一對應。
window_with_count(count, skip)
window_with_count 的這個變體會立即開啟第一個視窗。它會從來源 Observable 每跳過 skip 個項目時開啟一個新的視窗（舉例來說，如果 skip 為 3，則它會從每第三個項目開始開啟一個新的視窗）。當該視窗發射 count 個項目，或是從來源 Observable 收到 onCompleted 或 onError 通知時，它會關閉每個視窗。如果 skip = count，則此行為與 window_with_count(count) 相同；如果 skip < count，則會發射重疊 count − skip 個項目的視窗；如果 skip > count，則會在每個視窗之間從來源 Observable 捨棄 skip − count 個項目。
window_with_time(timespan[,scheduler])
window_with_time(timespan,timeshift[,scheduler])
window_with_time 的這個變體會立即開啟第一個視窗。它會每隔 timespan 毫秒關閉當前開啟的視窗並開啟另一個視窗（可選擇在特定的 Scheduler 上測量）。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉當前開啟的視窗。window_with_time 的這個變體會發射一系列不重疊的視窗，這些視窗的整體發射與來源 Observable 的發射一一對應。
如果您未指定 Scheduler，則 window_with_time 的這個變體預設會使用 timeout Scheduler 作為其計時器。
window_with_time_or_count(timespan,count[,scheduler])
window_with_time_or_count 會立即開啟第一個視窗。它會每隔 timespan 毫秒關閉當前開啟的視窗並開啟另一個視窗（可選擇在特定的 Scheduler 上測量），或是當前開啟的視窗發射了 count 個項目時。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉當前開啟的視窗。window_with_time_or_count 會發射一系列不重疊的視窗，這些視窗的整體發射與來源 Observable 的發射一一對應。
如果您未指定 Scheduler，則 window_with_time_or_count 的這個變體預設會使用 timeout Scheduler 作為其計時器。
window_with_count(count, skip)
Rx.rb 將此運算子實作為 window_with_count。它會立即開啟第一個視窗。然後，它會從來源 Observable 每跳過 skip 個項目時開啟一個新的視窗（舉例來說，如果 skip 為 3，則它會從每第三個項目開始開啟一個新的視窗）。當該視窗發射 count 個項目，或是從來源 Observable 收到 onCompleted 或 onError 通知時，它會關閉每個視窗。如果 skip = count，則來源 Observable 發射的項目與視窗 Observables 發射的項目之間存在一對一的對應關係；如果 skip < count，則視窗將重疊 count − skip 個項目；如果 skip > count，則視窗將在每個視窗之間從來源 Observable 捨棄 skip − count 個項目。
RxScala 將此運算子實作為 sliding（建立可能重疊或有間隔的視窗）和 tumbling（建立整體發射與來源 Observable 的發射一一對應的視窗）。
sliding(timespan,timeshift,count[,scheduler])
sliding 的這個變體會立即開啟第一個視窗，然後每隔 timeshift 時間段（以 Duration 物件的形式，並且可選擇在特定的 Scheduler 上）開啟一個新的視窗。它會在自該視窗開啟以來經過 timespan 時間段後，或是在該視窗上發射 count 個項目後，關閉當前開啟的視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉任何當前開啟的視窗。
sliding(timespan,timeshift[,scheduler])
sliding 的這個變體會立即開啟第一個視窗，然後每隔 timeshift 時間段（以 Duration 物件的形式，並且可選擇在特定的 Scheduler 上）開啟一個新的視窗。它會在自該視窗開啟以來經過 timespan 時間段後，關閉當前開啟的視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉任何當前開啟的視窗。
sliding(count,skip)
sliding 的這個變體會立即開啟第一個視窗。它會從來源 Observable 每跳過 skip 個項目時開啟一個新的視窗（舉例來說，如果 skip 為 3，則它會從每第三個項目開始開啟一個新的視窗）。當該視窗發射 count 個項目，或是從來源 Observable 收到 onCompleted 或 onError 通知時，它會關閉每個視窗。如果 skip = count，則此行為與 tumbling(count) 相同；如果 skip < count，則會發射重疊 count − skip 個項目的視窗；如果 skip > count，則會在每個視窗之間從來源 Observable 捨棄 skip − count 個項目。
sliding(openings,closings)
當 sliding 觀察到 openings Observable 發射一個 Opening 物件時，它會開啟一個視窗，同時呼叫 closings 來產生與該視窗關聯的關閉 Observable。當該關閉 Observable 發射一個項目時，sliding 會關閉該視窗。
tumbling(timespan,count[,scheduler])
tumbling 的這個變體會立即開啟第一個視窗。它會每隔 timespan 時間段（Duration，可選擇在特定的 Scheduler 上測量）或當前開啟的視窗發射了 count 個項目時，關閉當前開啟的視窗並開啟另一個視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉當前開啟的視窗。
tumbling(timespan[,scheduler])
tumbling 的這個變體會立即開啟第一個視窗。它會每隔 timespan 時間段（Duration，可選擇在特定的 scheduler 上）關閉當前開啟的視窗並開啟另一個視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉當前開啟的視窗。
tumbling(count)
tumbling 的這個變體會立即開啟第一個視窗。當前視窗發射了 count 個項目時，它會關閉當前開啟的視窗並立即開啟一個新的視窗。如果它從來源 Observable 收到 onCompleted 或 onError 通知，也會關閉當前開啟的視窗。
tumbling(boundary)
tumbling 的這個變體會將第二個 Observable 作為參數。每當這個第二個 Observable 發射一個項目時，tumbling 就會關閉目前的 Observable 視窗（如果有的話）並開啟一個新的視窗。