窗口 类似于 缓冲区，但它不是发出来自源可观察对象的数据包，而是发出可观察对象，每个可观察对象发出来自源可观察对象的一个子集，然后以 onCompleted 通知结束。
与 缓冲区 一样，窗口 也有多种类型，每种类型都有自己的方法将原始可观察对象细分为产生的可观察对象发射，每个发射都包含对原始发射项目的“窗口”。在 窗口 运算符的术语中，当窗口“打开”时，这意味着一个新的可观察对象被发出，并且该可观察对象将开始发出由源可观察对象发出的项目。当窗口“关闭”时，这意味着发出的可观察对象停止发出来自源可观察对象的项目，并以 onCompleted 通知向其观察者发出信号。
RxClojure 将此运算符实现为 partition-all
partition-all 会立即打开其第一个窗口。它从源可观察对象中的每 step 个项目开始打开一个新窗口（例如，如果 step 为 3，那么它将从每第三个项目开始打开一个新窗口）。它在该窗口发出 n 个项目时，或者在从源可观察对象接收到 onCompleted 或 onError 通知时，关闭每个窗口。如果 step = n（如果你省略了 step 参数，这是默认情况），那么窗口大小将与步长大小相同，源可观察对象发出的项目与窗口可观察对象集合发出的项目之间将存在一对一对应关系。如果 step < n，窗口将重叠 n − step 个项目；如果 step > n，窗口将在每个窗口之间丢弃 step − n 个项目。
RxCpp 将此运算符实现为 window 的两个变体，window_with_time 的两个变体，以及 window_with_time_or_count
ReactiveXwindow(count)
window 的此变体会立即打开其第一个窗口。每当当前窗口发出 count 个项目时，它都会关闭当前打开的窗口，并立即打开一个新窗口。如果它从源可观察对象接收到 onCompleted 或 onError 通知，它也会关闭当前打开的窗口。window 的此变体发出一系列不重叠的窗口，其累积发射与源可观察对象的发射一一对应。
window(count, skip)
window 的此变体会立即打开其第一个窗口。它从源可观察对象中的每 skip 个项目开始打开一个新窗口（例如，如果 skip 为 3，那么它将从每第三个项目开始打开一个新窗口）。它在该窗口发出 count 个项目时，或者在从源可观察对象接收到 onCompleted 或 onError 通知时，关闭每个窗口。如果 skip = count，那么它的行为将与 window(source, count) 相同；如果 skip < count，它将发出重叠 count − skip 个项目的窗口；如果 skip > count，它将发出在每个窗口之间丢弃 skip − count 个项目的窗口。
window_with_time(period[, coordination])![window_with_time(period[,coordination])](images/window_with_time5.png)
window_with_time 的此变体会立即打开其第一个窗口。它会关闭当前打开的窗口，并每隔 period 时间（一个持续时间，可以选择由给定的协调计算）打开另一个窗口。如果它从源可观察对象接收到 onCompleted 或 onError 通知，它也会关闭当前打开的窗口。window_with_time 的此变体发出一系列不重叠的窗口，其累积发射与源可观察对象的发射一一对应。
window_with_time(period, skip[, coordination])![window_with_time(period,skip[,coordination])](images/window_with_time7.png)
window_with_time 的此变体会立即打开其第一个窗口。它会在打开窗口后的 period 时间（一个持续时间，可以选择由给定的协调计算）后关闭当前打开的窗口，并在打开上一个窗口后的 skip 时间（一个持续时间，可以选择由给定的协调计算）后打开一个新窗口。如果它从源可观察对象接收到 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 个项目时，关闭当前打开的窗口并打开另一个窗口。如果它从源可观察对象接收到 onCompleted 或 onError 通知，它也会关闭当前打开的窗口。window_with_time_or_count 发出一系列不重叠的窗口，其累积发射与源可观察对象的发射一一对应。
RxGroovy 中有几种 窗口 的变体。
window(closingSelector)
window 的此变体会立即打开其第一个窗口。每当它观察到从 closingSelector 返回的可观察对象发射的某个对象时，它都会关闭当前打开的窗口，并立即打开一个新窗口。通过这种方式，window 的此变体发出一系列不重叠的窗口，其累积发射与源可观察对象的发射一一对应。
window(Func0)window(windowOpenings, closingSelector)
window 的此变体每当观察到 windowOpenings 可观察对象发射 Opening 对象时，都会打开一个窗口，同时调用 closingSelector 来生成与该窗口关联的关闭可观察对象。当该关闭可观察对象发射一个对象时，window 将关闭该窗口。由于当前打开的窗口的关闭和新窗口的打开是由独立的可观察对象控制的活动，因此 window 的此变体可能会创建重叠的窗口（重复来自源可观察对象的项目）或留下间隙（丢弃来自源可观察对象的项目）。
window(Observable,Func1)window(count)
window 的此变体会立即打开其第一个窗口。每当当前窗口发出 count 个项目时，它都会关闭当前打开的窗口，并立即打开一个新窗口。如果它从源可观察对象接收到 onCompleted 或 onError 通知，它也会关闭当前打开的窗口。window 的此变体发出一系列不重叠的窗口，其累积发射与源可观察对象的发射一一对应。
window(int)window(count, skip)
window 的此变体会立即打开其第一个窗口。它从源可观察对象中的每 skip 个项目开始打开一个新窗口（例如，如果 skip 为 3，那么它将从每第三个项目开始打开一个新窗口）。它在该窗口发出 count 个项目时，或者在从源可观察对象接收到 onCompleted 或 onError 通知时，关闭每个窗口。如果 skip = count，那么它的行为将与 window(source, count) 相同；如果 skip < count，它将发出重叠 count − skip 个项目的窗口；如果 skip > count，它将发出在每个窗口之间丢弃 skip − count 个项目的窗口。
window(int,int)window(timespan, unit[, scheduler])![window(timespan, unit[, scheduler])](images/window5.png)
window 的此变体会立即打开其第一个窗口。它会关闭当前打开的窗口，并每隔 timespan 时间（以 unit 为单位，可以选择在特定的 调度器 上）打开另一个窗口。如果它从源可观察对象接收到 onCompleted 或 onError 通知，它也会关闭当前打开的窗口。window 的此变体发出一系列不重叠的窗口，其累积发射与源可观察对象的发射一一对应。
如果你没有指定调度器，那么 window 的此变体默认情况下会使用 computation 调度器作为其计时器。
window(long,TimeUnit)window(long,TimeUnit,Scheduler)window(timespan, unit, count[, scheduler])![window(timespan, unit, count[, scheduler])](images/window6.png)
window 的此变体会立即打开其第一个窗口。它会在每隔 timespan 时间（以 unit 为单位，可以选择在特定的 调度器 上）或当前打开的窗口发出 count 个项目时，关闭当前打开的窗口并打开另一个窗口。如果它从源可观察对象接收到 onCompleted 或 onError 通知，它也会关闭当前打开的窗口。window 的此变体发出一系列不重叠的窗口，其累积发射与源可观察对象的发射一一对应。
如果你没有指定调度器，那么 window 的此变体默认情况下会使用 computation 调度器作为其计时器。
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 为单位，可以选择在特定的 调度器 上）打开一个新窗口。它会在打开该窗口后的 timespan 时间内关闭当前打开的窗口。如果它从源可观察对象接收到 onCompleted 或 onError 通知，它也会关闭任何当前打开的窗口。根据你如何设置 timespan 和 timeshift，此操作产生的窗口可能会重叠或有间隙。
如果你没有指定调度器，那么 window 的此变体默认情况下会使用 computation 调度器作为其计时器。
window(long,long,TimeUnit)window(long,long,TimeUnit,Scheduler)你可以使用 窗口 运算符来实现背压（即处理可能产生项目的速度超过其观察者消耗速度的可观察对象）。
窗口可以将许多项目的序列减少为较少的窗口项目序列，使它们更易于管理。例如，你可以定期从突发可观察对象发出项目的窗口，以固定的时间间隔。
Observable<Observable<Integer>> burstyWindowed = bursty.window(500, TimeUnit.MILLISECONDS);
或者，你可以选择对突发可观察对象发出的每 n 个项目发出一个新的项目窗口。
Observable<Observable<Integer>> burstyWindowed = bursty.window(5);
RxJava 中有几种 窗口 的变体。
window(closingSelector)
window 的此变体会立即打开其第一个窗口。每当它观察到从 closingSelector 返回的可观察对象发射的某个对象时，它都会关闭当前打开的窗口，并立即打开一个新窗口。通过这种方式，window 的此变体发出一系列不重叠的窗口，其累积发射与源可观察对象的发射一一对应。
window(Func0)window(windowOpenings, closingSelector)
window 的此变体每当观察到 windowOpenings 可观察对象发射 Opening 对象时，都会打开一个窗口，同时调用 closingSelector 来生成与该窗口关联的关闭可观察对象。当该关闭可观察对象发射一个对象时，window 将关闭该窗口。由于当前打开的窗口的关闭和新窗口的打开是由独立的可观察对象控制的活动，因此 window 的此变体可能会创建重叠的窗口（重复来自源可观察对象的项目）或留下间隙（丢弃来自源可观察对象的项目）。
window(Observable,Func1)window(count)
window 的此变体会立即打开其第一个窗口。每当当前窗口发出 count 个项目时，它都会关闭当前打开的窗口，并立即打开一个新窗口。如果它从源可观察对象接收到 onCompleted 或 onError 通知，它也会关闭当前打开的窗口。window 的此变体发出一系列不重叠的窗口，其累积发射与源可观察对象的发射一一对应。
window(int)window(count, skip)
window 的此变体会立即打开其第一个窗口。它从源可观察对象中的每 skip 个项目开始打开一个新窗口（例如，如果 skip 为 3，那么它将从每第三个项目开始打开一个新窗口）。它在该窗口发出 count 个项目时，或者在从源可观察对象接收到 onCompleted 或 onError 通知时，关闭每个窗口。如果 skip = count，那么它的行为将与 window(source, count) 相同；如果 skip < count，它将发出重叠 count − skip 个项目的窗口；如果 skip > count，它将发出在每个窗口之间丢弃 skip − count 个项目的窗口。
window(int,int)window(timespan, unit[, scheduler])
window 的此变体会立即打开其第一个窗口。它会关闭当前打开的窗口，并每隔 timespan 时间（以 unit 为单位，可以选择在特定的 调度器 上）打开另一个窗口。如果它从源可观察对象接收到 onCompleted 或 onError 通知，它也会关闭当前打开的窗口。window 的此变体发出一系列不重叠的窗口，其累积发射与源可观察对象的发射一一对应。
如果你没有指定调度器，那么 window 的此变体默认情况下会使用 computation 调度器作为其计时器。
window(long,TimeUnit)window(long,TimeUnit,Scheduler)window(timespan, unit, count[, scheduler])
window 的此变体会立即打开其第一个窗口。它会在每隔 timespan 时间（以 unit 为单位，可以选择在特定的 调度器 上）或当前打开的窗口发出 count 个项目时，关闭当前打开的窗口并打开另一个窗口。如果它从源可观察对象接收到 onCompleted 或 onError 通知，它也会关闭当前打开的窗口。window 的此变体发出一系列不重叠的窗口，其累积发射与源可观察对象的发射一一对应。
如果你没有指定调度器，那么 window 的此变体默认情况下会使用 computation 调度器作为其计时器。
window(long,TimeUnit,int)window(long,TimeUnit,int,Scheduler)window(timespan, timeshift, unit[, scheduler])
window 的此变体会立即打开其第一个窗口，并在此之后每隔 timeshift 时间（以 unit 为单位，可以选择在特定的 调度器 上）打开一个新窗口。它会在打开该窗口后的 timespan 时间内关闭当前打开的窗口。如果它从源可观察对象接收到 onCompleted 或 onError 通知，它也会关闭任何当前打开的窗口。根据你如何设置 timespan 和 timeshift，此操作产生的窗口可能会重叠或有间隙。
如果你没有指定调度器，那么 window 的此变体默认情况下会使用 computation 调度器作为其计时器。
window(long,long,TimeUnit)window(long,long,TimeUnit,Scheduler)你可以使用 窗口 运算符来实现背压（即处理可能产生项目的速度超过其观察者消耗速度的可观察对象）。
窗口可以将许多项目的序列减少为较少的窗口项目序列，使它们更易于管理。例如，你可以定期从突发可观察对象发出项目的窗口，以固定的时间间隔。
Observable<Observable<Integer>> burstyWindowed = bursty.window(500, TimeUnit.MILLISECONDS);
或者，你可以选择对突发可观察对象发出的每 n 个项目发出一个新的项目窗口。
Observable<Observable<Integer>> burstyWindowed = bursty.window(5);
window(windowClosingSelector)
window(windowOpenings, windowClosingSelector)
window(windowBoundaries)
window 的此变体接受一个第二个可观察对象作为参数。每当此第二个可观察对象发出一个项目时，window 就会关闭当前的可观察对象窗口（如果有）并打开一个新的窗口。
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 时间段（以毫秒为单位，可选地在特定 Scheduler 上测量）打开另一个窗口。如果它从源 Observable 收到 onCompleted 或 onError 通知，它也会关闭当前打开的窗口。此变体 windowWithTime 发出一系列不重叠的窗口，其集体发射与源 Observable 的发射一一对应。
如果未指定调度器，此变体 windowWithTime 默认使用 timeout 调度器作为其计时器。
windowWithTime(timeSpan,timeShift[,scheduler])
此变体 windowWithTime 会立即打开第一个窗口，并在之后每 timeshift 毫秒（可选地在特定 Scheduler 上测量）打开一个新窗口。它会在窗口打开后经过 timespan 毫秒后关闭当前打开的窗口。如果它从源 Observable 收到 onCompleted 或 onError 通知，它也会关闭任何当前打开的窗口。根据 timespan 和 timeshift 的设置方式，此操作产生的窗口可能会重叠或有间隙。
如果未指定调度器，此变体 windowWithTime 默认使用 timeout 调度器作为其计时器。
windowWithTimeOrCount(timeSpan,count[,scheduler])
windowWithTimeOrCount 会立即打开第一个窗口。它会关闭当前打开的窗口，并在每 timespan 毫秒（可选地在特定 Scheduler 上测量）或每当当前打开的窗口发出 count 个项目时打开另一个窗口。如果它从源 Observable 收到 onCompleted 或 onError 通知，它也会关闭当前打开的窗口。windowWithTimeOrCount 发出一系列不重叠的窗口，其集体发射与源 Observable 的发射一一对应。
如果未指定调度器，此变体 windowWithTimeOrCount 默认使用 timeout 调度器作为其计时器。
RxKotlin 中有几种 Window 变体。
window(closingSelector)
window 的此变体会立即打开其第一个窗口。每当它观察到从 closingSelector 返回的可观察对象发射的某个对象时，它都会关闭当前打开的窗口，并立即打开一个新窗口。通过这种方式，window 的此变体发出一系列不重叠的窗口，其累积发射与源可观察对象的发射一一对应。
window(windowOpenings, closingSelector)
window 的此变体每当观察到 windowOpenings 可观察对象发射 Opening 对象时，都会打开一个窗口，同时调用 closingSelector 来生成与该窗口关联的关闭可观察对象。当该关闭可观察对象发射一个对象时，window 将关闭该窗口。由于当前打开的窗口的关闭和新窗口的打开是由独立的可观察对象控制的活动，因此 window 的此变体可能会创建重叠的窗口（重复来自源可观察对象的项目）或留下间隙（丢弃来自源可观察对象的项目）。
window(count)
window 的此变体会立即打开其第一个窗口。每当当前窗口发出 count 个项目时，它都会关闭当前打开的窗口，并立即打开一个新窗口。如果它从源可观察对象接收到 onCompleted 或 onError 通知，它也会关闭当前打开的窗口。window 的此变体发出一系列不重叠的窗口，其累积发射与源可观察对象的发射一一对应。
window(count, skip)
window 的此变体会立即打开其第一个窗口。它从源可观察对象中的每 skip 个项目开始打开一个新窗口（例如，如果 skip 为 3，那么它将从每第三个项目开始打开一个新窗口）。它在该窗口发出 count 个项目时，或者在从源可观察对象接收到 onCompleted 或 onError 通知时，关闭每个窗口。如果 skip = count，那么它的行为将与 window(source, count) 相同；如果 skip < count，它将发出重叠 count − skip 个项目的窗口；如果 skip > count，它将发出在每个窗口之间丢弃 skip − count 个项目的窗口。
window(timespan, unit[, scheduler])
window 的此变体会立即打开其第一个窗口。它会关闭当前打开的窗口，并每隔 timespan 时间（以 unit 为单位，可以选择在特定的 调度器 上）打开另一个窗口。如果它从源可观察对象接收到 onCompleted 或 onError 通知，它也会关闭当前打开的窗口。window 的此变体发出一系列不重叠的窗口，其累积发射与源可观察对象的发射一一对应。
如果你没有指定调度器，那么 window 的此变体默认情况下会使用 computation 调度器作为其计时器。
window(timespan, unit, count[, scheduler])
window 的此变体会立即打开其第一个窗口。它会在每隔 timespan 时间（以 unit 为单位，可以选择在特定的 调度器 上）或当前打开的窗口发出 count 个项目时，关闭当前打开的窗口并打开另一个窗口。如果它从源可观察对象接收到 onCompleted 或 onError 通知，它也会关闭当前打开的窗口。window 的此变体发出一系列不重叠的窗口，其累积发射与源可观察对象的发射一一对应。
如果你没有指定调度器，那么 window 的此变体默认情况下会使用 computation 调度器作为其计时器。
window(timespan, timeshift, unit[, scheduler])
window 的此变体会立即打开其第一个窗口，并在此之后每隔 timeshift 时间（以 unit 为单位，可以选择在特定的 调度器 上）打开一个新窗口。它会在打开该窗口后的 timespan 时间内关闭当前打开的窗口。如果它从源可观察对象接收到 onCompleted 或 onError 通知，它也会关闭任何当前打开的窗口。根据你如何设置 timespan 和 timeshift，此操作产生的窗口可能会重叠或有间隙。
如果你没有指定调度器，那么 window 的此变体默认情况下会使用 computation 调度器作为其计时器。
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 的此变体接受一个第二个可观察对象作为参数。每当此第二个可观察对象发出一个项目时，window 就会关闭当前的可观察对象窗口（如果有）并打开一个新的窗口。
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 的发射一一对应。
如果未指定调度器，此变体 window_with_time 默认使用 timeout 调度器作为其计时器。
window_with_time_or_count(timespan,count[,scheduler])
window_with_time_or_count 会立即打开第一个窗口。它会关闭当前打开的窗口，并在每 timespan 毫秒（可选地在一个特定的 调度器 上测量）或当前打开的窗口发出 count 个项目时打开另一个窗口。如果从源 Observable 收到 onCompleted 或 onError 通知，它也会关闭当前打开的窗口。window_with_time_or_count 发出一系列非重叠的窗口，这些窗口的总发射量与源 Observable 的发射量一一对应。
如果你没有指定调度器，这个版本的 window_with_time_or_count 默认使用 timeout 调度器来计时。
window_with_count(count,skip)
Rx.rb 将此操作符实现为 window_with_count。它会立即打开第一个窗口。然后，它会从源 Observable 的每个 skip 项目开始打开一个新窗口（例如，如果 skip 为 3，则它会从每个第三个项目开始打开一个新窗口）。当该窗口发出 count 个项目或从源 Observable 收到 onCompleted 或 onError 通知时，它会关闭每个窗口。如果 skip = count，则源 Observable 发出的项目与窗口 Observable 发出的项目之间存在一一对应关系；如果 skip < count，则窗口将重叠 count − skip 个项目；如果 skip > count，则窗口将在每个窗口之间从源 Observable 中删除 skip − count 个项目。
RxScala 将此操作符实现为 sliding（创建可能重叠或有间隙的窗口）和 tumbling（创建其总发射量与源 Observable 一一对应的窗口）。
sliding(timespan,timeshift,count[,scheduler])
这个版本的 sliding 会立即打开第一个窗口，此后每 timeshift 时间段（以 Duration 对象的形式，可选地在特定的 调度器 上）打开一个新窗口。它会在自该窗口打开后经过 timespan 时间段或该窗口发出 count 个项目后关闭当前打开的窗口。如果从源 Observable 收到 onCompleted 或 onError 通知，它也会关闭任何当前打开的窗口。
sliding(timespan,timeshift[,scheduler])
这个版本的 sliding 会立即打开第一个窗口，此后每 timeshift 时间段（以 Duration 对象的形式，可选地在特定的 调度器 上）打开一个新窗口。它会在自该窗口打开后经过 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，可选地在特定的 调度器 上测量）或当前打开的窗口发出 count 个项目时打开另一个窗口。如果从源 Observable 收到 onCompleted 或 onError 通知，它也会关闭当前打开的窗口。
tumbling(timespan[,scheduler])
这个版本的 tumbling 会立即打开第一个窗口。它会关闭当前打开的窗口，并在每 timespan 时间段（一个 Duration，可选地在特定的 调度器 上测量）打开另一个窗口。如果从源 Observable 收到 onCompleted 或 onError 通知，它也会关闭当前打开的窗口。
tumbling(count)
这个版本的 tumbling 会立即打开第一个窗口。它会关闭当前打开的窗口，并在当前窗口发出 count 个项目时立即打开一个新的窗口。如果从源 Observable 收到 onCompleted 或 onError 通知，它也会关闭当前打开的窗口。
tumbling(boundary)
这个版本的 tumbling 将第二个 Observable 作为参数。每当这个第二个 Observable 发出项目时，tumbling 就会关闭当前的 Observable 窗口（如果有）并打开一个新的窗口。