import {GroupedObservable} from '@reactivex/rxjs/es6/operator/groupBy.js'

public class | source

GroupedObservable

Extends:

Observable → GroupedObservable

该 Observable 表示因具有共同的键而属于同一个组的值。由 GroupedObservable 发出的值来自于源 Observable 。共同的键可作为 GroupedObservable 实例上的 key 字段。

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	defer(observableFactory: function(): SubscribableOrPromise): Observable 创建一个 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	never(): Observable 创建一个不向观察者发出任何项的 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	[Symbol_observable](): Observable 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	combineAll(project: function): Observable 通过等待外部 Observable 完成然后应用 combineLatest ，将高阶 Observable 转化为一阶 Observable。
public	combineLatest(other: ObservableInput, project: function): Observable 组合多个 Observables 来创建一个 Observable ，该 Observable 的值根据每个输入 Observable 的最新值计算得出的。
public	concat(other: ObservableInput, scheduler: Scheduler): Observable 创建一个输出 Observable，它在当前 Observable 之后顺序地发出每个给定的输入 Observable 中的所有值。
public	concatAll(): Observable 通过顺序地连接内部 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	dematerialize(): Observable 将 Notification 对象的 Observable 转换成它们所代表的发送。
public	distinct(keySelector: function, flushes: Observable): Observable 返回 Observable，它发出由源 Observable 所发出的所有与之前的项都不相同的项。
public	distinctUntilChanged(compare: function): Observable 返回 Observable，它发出源 Observable 发出的所有与前一项不相同的项。
public	distinctUntilKeyChanged(key: string, compare: function): Observable 返回 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	exhaust(): Observable 当前一个内部 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	ignoreElements(): Observable 忽略源 Observable 所发送的所有项，只传递 `complete` 或 `error` 的调用。
public	isEmpty(): Observable 如果源 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	materialize(): Observable<Notification<T>> 表示源 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	onErrorResumeNext(observables: ...ObservableInput): Observable 当任何提供的 Observable 发出完成或错误通知时，它会立即地订阅已传入下一个 Observable 。
public	pairwise(): Observable<Array<T>> 将一系列连续的发送成对的组合在一起，并将这些分组作为两个值的数组发出。
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	publishBehavior(value: *): ConnectableObservable<T>
public	publishLast(): ConnectableObservable<T>
public	publishReplay(bufferSize: , windowTime: , scheduler: *): ConnectableObservable<T>
public	race(): Observable 返回 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	repeat(count: number): Observable 返回的 Observable 重复由源 Observable 所发出的项的流，最多可以重复 count 次。
public	repeatWhen(notifier: function(notifications: Observable): Observable): Observable 返回的 Observalbe 是源 Observable 的镜像，除了 `complete` 。如果源 Observable 调用了 `complete`，这个方法会发出给 `notifier` 返回的 Observable 。如果这个 Observale 调用了 `complete` 或 `error`，那么这个方法会在子 subscription 上调用 `complete` 或 `error` 。否则，此方法将重新订阅源 Observable。
public	retry(count: number): Observable 返回一个 Observable，该 Observable 是源 Observable 不包含错误异常的镜像。如果源 Observable 发生错误, 这个方法不会传播错误而是会不断的重新订阅源 Observable 直到达到最大重试次数 (由数字参数指定)。
public	retryWhen(notifier: function(errors: Observable): Observable): Observable 返回一个 Observable，该 Observable 是源 Observable 不包含错误异常的镜像。如果源头 Observable 触发 `error`，这个方法会发出引起错误的 Throwable 给 `notifier` 返回的 Observable。如果该 Observable 触发 `complete` 或者 `error` 则该方法会使子订阅触发 `complete` 和 `error`。否则该方法会重新订阅源 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	share(): Observable<T> 返回一个新的 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	skip(count: Number): Observable 返回一个 Observable，该 Observable 跳过源 Observable 发出的前N个值(N = count)。
public	skipLast(count: number): Observable<T> 跳过源 Observable 最后发出的的N个值 (N = count)。
public	skipUntil(notifier: Observable): Observable<T> 返回一个 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	switch(): Observable<T> 通过只订阅最新发出的内部 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	takeUntil(notifier: Observable): Observable<T> 发出源 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	toArray(): Observable<any[]> \| WebSocketSubject<T> \| Observable<T>
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	withLatestFrom(other: ObservableInput, project: Function): Observable 结合源 Observable 和另外的 Observables 以创建新的 Observable，该 Observable 的值由每个 Observable 最新的值计算得出，当且仅当源发出的时候。
public	zipAll(project: *): Observable<R> \| WebSocketSubject<T> \| Observable<T>
public	zipProto(observables: *): Observable<R>