表示在任何时间量内的任何一组值。这是 RxJS 的最基本构建块。

class Observable<T> implements Subscribable {
  static create: Function
  static if: typeof iif
  static throw: typeof throwError
  constructor(subscribe?: (this: Observable<T>, subscriber: Subscriber<T>) => TeardownLogic)
  _isScalar: boolean
  source: Observable<any>
  operator: Operator<any, T>
  lift<R>(operator: Operator<T, R>): Observable<R>
  subscribe(observerOrNext?: NextObserver<T> | ErrorObserver<T> | CompletionObserver<T> | ((value: T) => void), error?: (error: any) => void, complete?: () => void): Subscription
  _trySubscribe(sink: Subscriber<T>): TeardownLogic
  forEach(next: (value: T) => void, promiseCtor?: PromiseConstructorLike): Promise<void>
  pipe(...operations: OperatorFunction<any, any>[]): Observable<any>
  toPromise(promiseCtor?: PromiseConstructorLike): Promise<T>
}

子类

• ConnectableObservable
• GroupedObservable
• Subject
  • BehaviorSubject
  • ReplaySubject
  • AsyncSubject

静态特性

建设者

constructor(subscribe?: (this: Observable<T>, subscriber: Subscriber<T>) => TeardownLogic)参量订阅可选的。默认值为 undefined。最初订阅 Observable 时调用的函数。该函数被赋予一个订阅者，可以为其输入新值 next，或者 error 可以调用一个方法来引发错误，或者 complete 可以调用一个方法 来通知成功完成。

物产

方法

电梯（） 创建一个新的 Observable，将其作为源，并将传递的运算符定义为新的 Observable 的运算符。 lift<R>(operator: Operator<T, R>): Observable<R>

订阅（） 调用 Observable 的执行并注册 Observer 处理程序以获取其发出的通知。 5重载...subscribe(observer?: PartialObserver<T>): Subscription

returnsSubscription

subscribe(next: null, error: null, complete: () => void): Subscription

returnsSubscription``subscribe(next: null, error: (error: any) => void, complete?: () => void): Subscription

returns Subscription``subscribe(next: (value: T) => void, error: null, complete: () => void): Subscription

returnsSubscription``subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription

当您拥有所有这些 Observable 时，请使用它，但仍然没有任何反应。subscribe不是常规运算符，而是调用 Observable 内部 subscribe 函数的方法。例如，它可能是传递给 Observable 的构造函数的函数，但是在大多数情况下，它是库实现，它定义 Observable 将发出的内容以及何时发出。这意味着调用 subscribe 实际上是 Observable 开始其工作的时刻，而不是通常被认为是创建的时刻。除了开始执行 Observable 之外，此方法还允许您侦听 Observable 发出的值以及完成或发生错误的时间。您可以通过以下两种方式来实现。第一种方法是创建一个实现 Observer 接口的对象。它应该具有由该接口定义的方法，但是请注意，它应该只是一个常规的 JavaScript 对象，您可以按照自己想要的任何方式（ES6 类，经典函数构造函数，对象文字等）创建自己。特别是不要尝试使用任何 RxJS 实现细节来创建观察者-您不需要它们。还要记住，您的对象不必实现所有方法。如果发现自己创建了一种不执行任何操作的方法，则可以简单地忽略它。但是请注意，如果 error 未提供该方法，则所有错误都将保留。第二种方法是完全放弃 Observer 对象，仅提供回调函数代替其方法。这意味着您可以提供三个函数作为的参数 subscribe，其中第一个函数等效于 next 方法，第二个函数等效于方法，error 第三个函数等效于 complete 方法。与 Observer 一样，如果不需要监听某些内容，则可以省略函数，最好通过 undefined 或 null，因为 subscribe 可以通过将它们放在函数调用中的位置来识别它们。当涉及到 error 功能时，就像以前一样（如果未提供），将抛出 Observable 发出的错误。无论 subscribe 使用哪种调用方式，在两种情况下都将返回 Subscription 对象。该对象允许您对其进行调用unsubscribe，这将停止 Observable 所做的工作，并清除 Observable 使用的所有资源。请注意，取消订阅不会调用 complete 提供给 subscribe 函数的回调，该回调保留给来自 Observable 的常规完成信号。请记住，提供给的回调 subscribe 不能保证被异步调用。它是一个 Observable 本身，它决定何时调用这些函数。例如 of ，默认情况下会同步发出其所有值。始终检查文档以了解给定的 Observable 在订阅时的行为，以及是否可以使用修改其默认行为 scheduler。

例

订阅观察者

import { of } from 'rxjs';


const sumObserver = {
  sum: 0,
  next(value) {
    console.log('Adding: ' + value);
    this.sum = this.sum + value;
  },
  error() {
    // We actually could just remove this method,
    // since we do not really care about errors right now.
  },
  complete() {
    console.log('Sum equals: ' + this.sum);
  }
};


of(1, 2, 3) // Synchronously emits 1, 2, 3 and then completes.
  .subscribe(sumObserver);


// Logs:
// "Adding: 1"
// "Adding: 2"
// "Adding: 3"
// "Sum equals: 6"

订阅功能

import { of } from 'rxjs'


let sum = 0;


of(1, 2, 3).subscribe(
  value => {
    console.log('Adding: ' + value);
    sum = sum + value;
  },
  undefined,
  () => console.log('Sum equals: ' + sum)
);


// Logs:
// "Adding: 1"
// "Adding: 2"
// "Adding: 3"
// "Sum equals: 6"

取消订阅

import { interval } from 'rxjs';


const subscription = interval(1000).subscribe(
  num => console.log(num),
  undefined,
  () => {
    // Will not be called, even when cancelling subscription.
    console.log('completed!');
  }
);


setTimeout(() => {
  subscription.unsubscribe();
  console.log('unsubscribed!');
}, 2500);


// Logs:
// 0 after 1s
// 1 after 2s
// "unsubscribed!" after 2.5s

_trySubscribe（） _trySubscribe(sink: Subscriber<T>): TeardownLogic

returns`Observable

`pipe<A>(op1: OperatorFunction<T, A>): Observable<A>

<C>`pipe<A, B, C, D>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Observable<D>

<E>`pipe<A, B, C, D, E, F>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>): Observable<F>

<F>`pipe<A, B, C, D, E, F, G>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>): Observable<G>

<G>`pipe<A, B, C, D, E, F, G, H>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>): Observable<H>

<H>`pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): Observable<I>

<I>`pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>, ...operations: OperatorFunction<any, any>[]): Observable<{}>

承诺（） 3重载...toPromise<T>(): Promise<T>参量没有参数。returnsPromise<T>``toPromise<T>(PromiseCtor: any): Promise<T>

returnsPromise<T>``toPromise<T>(PromiseCtor: PromiseConstructorLike): Promise<T>