Question

通过阅读一些文档和问题，我发现它有点不清楚天气使用first（）或take（1）实际取消订阅完成时。我想我的困惑是完全的＆＃39; vs＆＃39;取消订阅＆＃39;。要说一个可观察的完成，这是否也意味着订阅被取消订阅？我正在考虑将其用于垃圾收集，而我需要知道，在第一个（）或完成（1）之后，observable不会保留任何引用。

如果这些功能没有取消订阅，我需要知道完成后取消订阅的最简单方法。或者这甚至是必要的吗？

Answer 1

源代码中的一些内容，

（do）first（）并在完成后取（1）实际取消订阅

看起来如此。

take.ts

protected _next(value: T): void {
  const total = this.total;
  const count = ++this.count;
  if (count <= total) {
    this.destination.next(value);
    if (count === total) {
      this.destination.complete();
      this.unsubscribe();
    }
  }
}

要说一个可观察的完成，这是否也意味着订阅被取消订阅？

在 Subscription.ts 中，遇到过这种情况（文档中没有看到）

/**
 * Adds a tear down to be called during the unsubscribe() of this
 * Subscription.
 *
   ...
 */
add(teardown: TeardownLogic): Subscription {

因此我认为可以使用拆解来验证是否已调用取消订阅。

const source1 = Observable.range(1, 10).take(6)

const subscription1 = source1.subscribe(x => console.log('subscription1'))
  .add(() => console.log('teardown1'))
// Emits 6x then 'teardown1'

const subscription2 = source1.take(4).subscribe(x => console.log('subscription2'))
  .add(() => console.log('teardown2'))
// Emits 4x then 'teardown2'

但请注意，take()仅取消订阅自身的下游，而不是所有可观察的订阅者

const source2 = Observable.range(1, 10)

const subscription3 = source2.subscribe(x => console.log('subscription3'))
  .add(() => console.log('teardown3'))
// Emits 10x then 'teardown3'

const subscription4 = source2.take(5).subscribe(x => console.log('subscription4'))
  .add(() => console.log('teardown4'))
// Emits 5x then 'teardown4'

我需要知道，在第一次（）或完成（1）之后，observable没有保留任何引用。

这有点棘手，这是Observable.subscribe()方法。似乎观察者没有保留对它的三个参数中的任何一个的引用，而是订阅保持对可观察者的引用。

subscribe(observerOrNext?: PartialObserver<T> | ((value: T) => void),
          error?: (error: any) => void,
          complete?: () => void): Subscription {

  const { operator } = this;
  const sink = toSubscriber(observerOrNext, error, complete);

  if (operator) {
    operator.call(sink, this.source);
  } else {
    sink.add(this.source ? this._subscribe(sink) : this._trySubscribe(sink));
  }

  if (sink.syncErrorThrowable) {
    sink.syncErrorThrowable = false;
    if (sink.syncErrorThrown) {
      throw sink.syncErrorValue;
    }
  }
  return sink;
}

这可以在以下测试代码中看到。订阅处于活动状态（已关闭：false）时，订阅者具有_subscriptions

中引用的可观察对象

const source3 = Observable.interval(1000)
const subscription5 = source3.subscribe(x => {})
console.log(source3)
console.log(subscription5)

控制台输出：

IntervalObservable 
  period: 1000
  scheduler: AsyncScheduler {...}
  _isScalar: false
  __proto__: Observable

Subscriber 
  closed: false
  destination: SafeSubscriber {...}
  isStopped: false
  syncErrorThrowable: false
  syncErrorThrown: false
  syncErrorValue: null
  _parent: null
  _parents: null
  _subscriptions: [AsyncAction]
  __proto__: Subscription

但是当我们使用take(1)

关闭订阅时

const source3 = Observable.interval(1000).take(1)
const subscription5 = source3.subscribe(x => {})
console.log(source3)
console.log(subscription5)

订阅者_subscriptions设置为null，释放引用。

Subscriber 
  closed: true
  destination: SafeSubscriber {...}
  isStopped: true
  syncErrorThrowable: false
  syncErrorThrown: false
  syncErrorValue: null
  _parent: null
  _parents: null
  _subscriptions: null
  __proto__: Subscription

我不确定这可以被视为所有可观察/运营商/订户链的明确证据，但至少表明了验证您的特定用例的方法。

Angular 2/4使用RxJS - 完成vs取消订阅关于take（1）和first（）

1 个答案: