Home Manual Reference Source Test Repository
import {ReplaySubject} from '@reactivex/rxjs/es6/ReplaySubject.js'
public class | source

ReplaySubject

Extends:

ObservableSubject → ReplaySubject

Test:

Inherited Summary

From class Observable
public static

bindCallback(func: function, selector: function, scheduler: Scheduler): function(...params: *): Observable

把回调API转化为返回Observable的函数。

public static

bindNodeCallback(func: function, selector: function, scheduler: Scheduler): *

把 Node.js 式回调API转换为返回 Observable 的函数。

public static

combineLatest(observable1: ObservableInput, observable2: ObservableInput, project: function, scheduler: Scheduler): Observable

组合多个 Observables 来创建一个 Observable ,该 Observable 的值根据每个输入 Observable 的最新值计算得出的。

public static

concat(input1: ObservableInput, input2: ObservableInput, scheduler: Scheduler): Observable

创建一个输出 Observable,该 Observable 顺序的发出每个输入 Observable 的所有值。

public static

create(onSubscription: function(observer: Observer): TeardownLogic): Observable

创建一个新的 Observable ,当观察者( Observer )订阅该 Observable 时,它会执行指定的函数。

public static

创建一个 Observable,当被订阅的时候,调用 Observable 工厂为每个观察者创建新的 Observable。

public static

empty(scheduler: Scheduler): Observable

创建一个什么数据都不发出并且立马完成的 Observable。

public static

forkJoin(sources: *): any

public static

from(ish: ObservableInput<T>, scheduler: Scheduler): Observable<T>

从一个数组、类数组对象、Promise、迭代器对象或者类 Observable 对象创建一个 Observable.

public static

fromEvent(target: EventTargetLike, eventName: string, options: EventListenerOptions, selector: SelectorMethodSignature<T>): Observable<T>

创建一个 Observable,该 Observable 发出来自给定事件对象的指定类型事件。

public static

fromEventPattern(addHandler: function(handler: Function): any, removeHandler: function(handler: Function, signal?: any): void, selector: function(...args: any): T): Observable<T>

从一个基于 addHandler/removeHandler 方法的API创建 Observable。

public static

fromPromise(promise: PromiseLike<T>, scheduler: Scheduler): Observable<T>

将 Promise 转化为 Observable。

public static

interval(period: number, scheduler: Scheduler): Observable

创建一个 Observable ,该 Observable 使用指定的 IScheduler ,并以指定时间间隔发出连续的数字。

public static

merge(observables: ...ObservableInput, concurrent: number, scheduler: Scheduler): Observable

创建一个输出 Observable ,它可以同时发出每个给定的输入 Observable 中值。

public static

创建一个不向观察者发出任何项的 Observable 。

public static

of(values: ...T, scheduler: Scheduler): Observable<T>

创建一个 Observable,它会依次发出由你提供的参数,最后发出完成通知。 发出你提供的参数,然后完成。

public static

range(start: number, count: number, scheduler: Scheduler): Observable

创建一个 Observable ,它发出指定范围内的数字序列。

public static

throw(将具体的: any, scheduler: Scheduler): Observable

创建一个不发送数据给观察者并且立马发出错误通知的 Observable。

public static

timer(initialDelay: number | Date, period: number, scheduler: Scheduler): Observable

创建一个 Observable,该 Observable 在初始延时(initialDelay)之后开始发送并且在每个时间周期( period)后发出自增的数字。

public static

webSocket(urlConfigOrSource: string | WebSocketSubjectConfig): WebSocketSubject

包装浏览器提供的兼容w3c的WebSocket对象.

public static

zip(observables: *): Observable<R>

将多个 Observable 组合以创建一个 Observable,该 Observable 的值是由所有输入 Observables 的值按顺序计算而来的。

public

An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable

public

audit(durationSelector: function(value: T): SubscribableOrPromise): Observable<T>

在另一个 Observable 决定的时间段里忽略源数据,然后发出源 Observable 中最新发出的值, 然后重复此过程。

public

auditTime(duration: number, scheduler: Scheduler): Observable<T>

duration 毫秒内忽略源值,然后发出源 Observable 的最新值, 并且重复此过程。

public

buffer(closingNotifier: Observable<any>): Observable<T[]>

缓冲源 Observable 的值直到 closingNotifier 发出。

public

bufferCount(bufferSize: number, startBufferEvery: number): Observable<T[]>

缓冲源 Observable 的值直到缓冲数量到达设定的 bufferSize.

public

bufferTime(bufferTimeSpan: number, bufferCreationInterval: number, maxBufferSize: number, scheduler: Scheduler): Observable<T[]>

在特定时间周期内缓冲源 Observable 的值。

public

bufferToggle(openings: SubscribableOrPromise<O>, closingSelector: function(value: O): SubscribableOrPromise): Observable<T[]>

缓冲源 Observable 的值,openings 发送的时候开始缓冲,closingSelector 发送的时候结束缓冲。

public

bufferWhen(closingSelector: function(): Observable): Observable<T[]>

缓冲源 Observable 的值, 使用关闭 Observable 的工厂函数来决定何时关闭、发出和重置缓冲区。

public

catch(selector: function): Observable

捕获 observable 中的错误,可以通过返回一个新的 observable 或者抛出错误对象来处理。

public

通过等待外部 Observable 完成然后应用 combineLatest ,将高阶 Observable 转化为一阶 Observable。

public

组合多个 Observables 来创建一个 Observable ,该 Observable 的值根据每个输入 Observable 的最新值计算得出的。

public

创建一个输出 Observable,它在当前 Observable 之后顺序地发出每个给定的输入 Observable 中的所有值。

public

通过顺序地连接内部 Observable,将高阶 Observable 转化为一阶 Observable 。

public

concatMap(project: function(value: T, ?index: number): ObservableInput, resultSelector: function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any): Observable

将源值投射为一个合并到输出 Observable 的 Observable,以串行的方式等待前一个完成再合并下一个 Observable。

public

concatMapTo(innerObservable: ObservableInput, resultSelector: function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any): Observable

将每个源值投射成同一个 Observable ,该 Observable 会以串行的方式多次合并到输出 Observable 中 。

public

count(predicate: function(value: T, i: number, source: Observable<T>): boolean): Observable

计算源的发送数量,并当源完成时发出该数值。

public

debounce(durationSelector: function(value: T): SubscribableOrPromise): Observable

只有在另一个 Observable 决定的一段特定时间经过后并且没有发出另一个源值之后,才从源 Observable 中发出一个值。

public

debounceTime(dueTime: number, scheduler: Scheduler): Observable

只有在特定的一段时间经过后并且没有发出另一个源值,才从源 Observable 中发出一个值。

public

defaultIfEmpty(defaultValue: any): Observable

如果源 Observable 在完成之前没有发出任何 next 值,则发出给定的值,否则返回 Observable 的镜像。

public

delay(delay: number | Date, scheduler: Scheduler): Observable

通过给定的超时或者直到一个给定的时间来延迟源 Observable 的发送。

public

delayWhen(delayDurationSelector: function(value: T): Observable, subscriptionDelay: Observable): Observable

在给定的时间范围内,延迟源 Observable 所有数据项的发送,该时间段由另一个 Observable 的发送决定。

public

Notification 对象的 Observable 转换成它们所代表的发送。

public

distinct(keySelector: function, flushes: Observable): Observable

返回 Observable,它发出由源 Observable 所发出的所有与之前的项都不相同的项。

public

返回 Observable,它发出源 Observable 发出的所有与前一项不相同的项。

public

返回 Observable,它发出源 Observable 发出的所有与前一项不相同的项,使用通过提供的 key 访问到的属性来检查两个项是否不同。

public

do(nextOrObserver: Observer | function, error: function, complete: function): Observable

为源 Observable 上的每次发送执行副作用,但返回的 Observable 与源 Observable 是相同的。

public

elementAt(index: number, defaultValue: T): Observable

只发出单个值,这个值位于源 Observable 的发送序列中的指定 index 处。

public

every(predicate: function, thisArg: any): Observable

返回的 Observable 发出是否源 Observable 的每项都满足指定的条件。

public

当前一个内部 Observable 还未完成的情况下,通过丢弃内部 Observable 使得 高阶 Observable 转换成一阶 Observable。

public

exhaustMap(project: function(value: T, ?index: number): ObservableInput, resultSelector: function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any): Observable

将每个源值投射成 Observable,只有当前一个投射的 Observable 已经完成, 这个 Observable 才会被合并到输出 Observable 中。

public

expand(project: function(value: T, index: number), concurrent: number): Observable

递归地将每个源值投射成 Observable,这个 Observable 会被合并到输出 Observable 中。

public

filter(predicate: function(value: T, index: number): boolean, thisArg: any): Observable

通过只发送源 Observable 的中满足指定 predicate 函数的项来进行过滤。

public

find(predicate: function(value: T, index: number, source: Observable<T>): boolean, thisArg: any): Observable<T>

只发出源 Observable 所发出的值中第一个满足条件的值。

public

findIndex(predicate: function(value: T, index: number, source: Observable<T>): boolean, thisArg: any): Observable<T>

只发出源 Observable 所发出的值中第一个满足条件的值的索引。

public

first(predicate: function(value: T, index: number, source: Observable<T>): boolean, resultSelector: function(value: T, index: number): R, defaultValue: R): Observable<T | R>

只发出由源 Observable 所发出的值中第一个(或第一个满足条件的值)。

public

forEach(next: Function, PromiseCtor: PromiseConstructor): Promise

public

groupBy(keySelector: function(value: T): K, elementSelector: function(value: T): R, durationSelector: function(grouped: GroupedObservable<K, R>): Observable<any>): Observable<GroupedObservable<K, R>>

根据指定条件将源 Observable 发出的值进行分组,并将这些分组作为 GroupedObservables 发出,每一个分组都是一个 GroupedObservable

public

忽略源 Observable 所发送的所有项,只传递 completeerror 的调用。

public

如果源 Observable 是空的话,它返回一个发出 true 的 Observable,否则发出 false 。

public

last(predicate: function): Observable

返回的 Observable 只发出由源 Observable 发出的最后一个值。它可以接收一个可选的 predicate 函数作为 参数,如果传入 predicate 的话则发送的不是源 Observable 的最后一项,而是发出源 Observable 中 满足 predicate 函数的最后一项。

public

letProto(func: *): Observable<R>

public

lift(operator: Operator): Observable

创建一个新的 Observable,以它作为源,并传递操作符的定义作为新的 observable 操作符。

public

map(project: function(value: T, index: number): R, thisArg: any): Observable<R>

将给定的 project 函数应用于源 Observable 发出的每个值,并将结果值作为 Observable 发出。

public

mapTo(value: any): Observable

每次源 Observble 发出值时,都在输出 Observable 上发出给定的常量值。

public

表示源 Observable 中的所有通知,每个通知都会在 Notification 对象中标记为 它们原始的通知类型,并会作为输出 Observable 的 next 通知。

public

max(comparer: Function): Observable

max 操作符操作的 Observable 发出数字(或可以与提供的函数进行比较的项)并且当源 Observable 完成时它发出单一项:最大值的项。

public

merge(other: ObservableInput, concurrent: number, scheduler: Scheduler): Observable

创建一个输出 Observable ,它可以同时发出每个给定的输入 Observable 中的所有值。

public

mergeAll(concurrent: number): Observable

将高阶 Observable 转换成一阶 Observable ,一阶 Observable 会同时发出在内部 Observables 上发出的所有值。

public

mergeMap(project: function(value: T, ?index: number): ObservableInput, resultSelector: function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any, concurrent: number): Observable

将每个源值投射成 Observable ,该 Observable 会合并到输出 Observable 中。

public

mergeMapTo(innerObservable: ObservableInput, resultSelector: function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any, concurrent: number): Observable

将每个源值投射成同一个 Observable ,该 Observable 会多次合并到输出 Observable 中。

public

mergeScan(accumulator: function(acc: R, value: T): Observable<R>, seed: *, concurrent: number): Observable<R>

在源 Observable 上应用 accumulator 函数,其中 accumulator 函数本身返回 Observable ,然后每个返回的中间 Observable 会被合并到输出 Observable 中。

public

min(comparer: Function): Observable<R>

min 操作符操作的 Observable 发出数字(或可以使用提供函数进行比较的项)并且当源 Observable 完成时它发出单一项:最小值的项。

public

multicast(subjectOrSubjectFactory: Function | Subject, selector: Function): Observable

返回的 Observable 发出对 ConnectableObservable 发出的项调用一个指定的 selector 函数的结果, ConnectableObservable 可以在潜在的多个流之间共享单个 subscription 。

public

observeOn(scheduler: IScheduler, delay: number): Observable<T>

使用指定的调度器来重新发出源 Observable 的所有通知。

public

当任何提供的 Observable 发出完成或错误通知时,它会立即地订阅已传入下一个 Observable 。

public

将一系列连续的发送成对的组合在一起,并将这些分组作为两个值的数组发出。

public

partition(predicate: function(value: T, index: number): boolean, thisArg: any): [Observable<T>, Observable<T>]

将源 Observable 一分为二,一个是所有满足 predicate 函数的值,另一个是所有 不满足 predicate 的值。

public

pluck(properties: ...string): Observable

将每个源值(对象)映射成它指定的嵌套属性。

public

publish(selector: Function): *

返回 ConnectableObservable,它是 Observable 的变种,它会一直等待,直到 connnect 方法被调用才会开始把值发送给那些订阅它的观察者。

public
public
public

publishReplay(bufferSize: *, windowTime: *, scheduler: *): ConnectableObservable<T>

public

返回 Observable,该 Observable 是源 Observable 和提供的 Observables 的组合中 第一个发出项的 Observable 的镜像。

public

reduce(accumulator: function(acc: R, value: T, index: number): R, seed: R): Observable<R>

在源 Observalbe 上应用 accumulator (累加器) 函数,然后当源 Observable 完成时,返回 累加的结果,可以提供一个可选的 seed 值。

public

返回的 Observable 重复由源 Observable 所发出的项的流,最多可以重复 count 次。

public

repeatWhen(notifier: function(notifications: Observable): Observable): Observable

返回的 Observalbe 是源 Observable 的镜像,除了 complete 。如果源 Observable 调用了 complete,这个方法会发出给 notifier 返回的 Observable 。如果这个 Observale 调用了 completeerror,那么这个方法会在子 subscription 上调用 completeerror 。否则,此方法将重新订阅源 Observable。

public

返回一个 Observable, 该 Observable 是源 Observable 不包含错误异常的镜像。 如果源 Observable 发生错误, 这个方法不会传播错误而是会不 断的重新订阅源 Observable 直到达到最大重试次数 (由数字参数指定)。

public

返回一个 Observable, 该 Observable 是源 Observable 不包含错误异常的镜像。 如果源头 Observable 触发 error, 这个方法会发出引起错误的 Throwable 给 notifier 返回的 Observable。 如果该 Observable 触发 complete 或者 error 则该方法会使子订阅触发 completeerror。 否则该方法会重新订阅源 Observable。

public

sample(notifier: Observable<any>): Observable<T>

发出源 Observable 最新发出的值当另一个 notifier Observable发送时。

public

sampleTime(period: number, scheduler: Scheduler): Observable<T>

在周期时间间隔内发出源 Observable 发出的最新值。

public

scan(accumulator: function(acc: R, value: T, index: number): R, seed: T | R): Observable<R>

对源 Observable 使用累加器函数, 返回生成的中间值, 可选的初始值。

public

sequenceEqual(compareTo: Observable, comparor: function): Observable

使用可选的比较函数,按顺序比较两个 Observables 的所有值,然后返回单个布尔值的 Observable, 以表示两个序列是否相等。 按顺序检查两个 Observables 所发出的所有值是否相等。

public

返回一个新的 Observable,该 Observable 多播(共享)源 Observable。 至少要有一个订阅者,该 Observable 才会被订阅并发出数据。 当所有的订阅者都取消订阅了,它会取消对源 Observable 的订阅。 因为 Observable 是多路传播的它使得流是 hot。 它是 `.publish().refCount()` 的别名。

public

shareReplay(bufferSize: *, windowTime: *, scheduler: *): *

public

single(predicate: Function): Observable<T>

该 Observable 发出源 Observable 所发出的值中匹配指定 predicate 函数的单个项。 如果源 Observable 发出多于1个数据项或者没有发出数据项, 分别以 IllegalArgumentException 和 NoSuchElementException 进行通知。

public

返回一个 Observable, 该 Observable 跳过源 Observable 发出的前N个值(N = count)。

public

skipLast(count: number): Observable<T>

跳过源 Observable 最后发出的的N个值 (N = count)。

public

返回一个 Observable,该 Observable 会跳过源 Observable 发出的值直到第二个 Observable 开始发送。

public

skipWhile(predicate: Function): Observable<T>

返回一个 Observable, 该 Observable 会跳过由源 Observable 发出的所有满足指定条件的数据项, 但是一旦出现了不满足条件的项,则发出在此之后的所有项。

public

startWith(values: ...T, scheduler: Scheduler): Observable

返回的 Observable 会先发出作为参数指定的项,然后再发出由源 Observable 所发出的项。

public

subscribe(observerOrNext: Observer | Function, error: Function, complete: Function): ISubscription

调用 Observable 的执行并注册 Observer 的处理器以便于发出通知。

public

subscribeOn(scheduler: Scheduler): Observable<T>

使用指定的 IScheduler 异步地订阅此 Observable 的观察者。

public

通过只订阅最新发出的内部 Observable ,将高阶 Observable 转换成一阶 Observable 。

public

switchMap(project: function(value: T, ?index: number): ObservableInput, resultSelector: function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any): Observable

将每个源值投射成 Observable,该 Observable 会合并到输出 Observable 中, 并且只发出最新投射的 Observable 中的值。

public

switchMapTo(innerObservable: ObservableInput, resultSelector: function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any): Observable

将每个源值投射成同一个 Observable ,该 Observable 会使用 switch 多次被打平 到输出 Observable 中。

public

take(count: number): Observable<T>

只发出源 Observable 最初发出的的N个值 (N = count)。

public

takeLast(count: number): Observable<T>

只发出源 Observable 最后发出的的N个值 (N = count)。

public

发出源 Observable 发出的值,直到 notifier Observable 发出值。

public

takeWhile(predicate: function(value: T, index: number): boolean): Observable<T>

发出在源 Observable 中满足 predicate 函数的每个值,并且一旦出现不满足 predicate 的值就立即完成。

public

throttle(durationSelector: function(value: T): SubscribableOrPromise, config: Object): Observable<T>

从源 Observable 中发出一个值,然后在由另一个 Observable 决定的期间内忽略 随后发出的源值,然后重复此过程。

public

throttleTime(duration: number, scheduler: Scheduler): Observable<T>

从源 Observable 中发出一个值,然后在 duration 毫秒内忽略随后发出的源值, 然后重复此过程。

public

timeInterval(scheduler: *): Observable<TimeInterval<any>> | WebSocketSubject<T> | Observable<T>

public

timeout(due: number, scheduler: Scheduler): Observable<R> | WebSocketSubject<T> | Observable<T>

public

timeoutWith(due: *, withObservable: *, scheduler: *): Observable<R> | WebSocketSubject<T> | Observable<T>

public

timestamp(scheduler: *): Observable<Timestamp<any>> | WebSocketSubject<T> | Observable<T>

public
public

toPromise(PromiseCtor: PromiseConstructor): Promise<T>

将 Observable 序列转换为符合 ES2015 标准的 Promise 。

public

window(windowBoundaries: Observable<any>): Observable<Observable<T>>

每当 windowBoundaries 发出项时,将源 Observable 的值分支成嵌套的 Observable 。

public

windowCount(windowSize: number, startWindowEvery: number): Observable<Observable<T>>

将源 Observable 的值分支成多个嵌套的 Observable ,每个嵌套的 Observable 最多发出 windowSize 个值。

public

windowToggle(openings: Observable<O>, closingSelector: function(value: O): Observable): Observable<Observable<T>>

将源 Observable 的值分支成嵌套的 Observable,分支策略是以 openings 发出项为起始,以 closingSelector 发出为结束。

public

windowWhen(closingSelector: function(): Observable): Observable<Observable<T>>

将源 Observable 的值分支成嵌套的 Observable ,通过使用关闭 Observable 的工厂函数来决定何时开启新的窗口。

public

结合源 Observable 和另外的 Observables 以创建新的 Observable, 该 Observable 的值由每 个 Observable 最新的值计算得出,当且仅当源发出的时候。

public

zipAll(project: *): Observable<R> | WebSocketSubject<T> | Observable<T>

public

zipProto(observables: *): Observable<R>