Rxjs Rx.Observable subscribe和forEach之间有什么区别

在创造了这样一个可观察的

var source = Rx.Observable.create(function(observer) {...});

订阅

source.subscribe(function(x) {});

public subscribe(observerOrNext: Observer | Function, error: Function, complete: Function): Subscription

和forEach

source.forEach(function(x) {});

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

在后面的中（但RxJS 4.0没有），这两个是不同的

订阅

source.subscribe(function(x) {});

public subscribe(observerOrNext: Observer | Function, error: Function, complete: Function): Subscription

Observable.subscribe

是您进行大部分真正可观察处理的地方。它返回一个订阅令牌，您可以使用该令牌取消订阅。当您不知道您订阅的事件/序列的持续时间，或者您可能需要在已知持续时间之前停止侦听时，这一点非常重要

forEach

source.forEach(function(x) {});

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

Observable.forEach

返回一个承诺，该承诺将在Observable完成或出现错误时解决或拒绝。它旨在澄清以下情况：您正在以更“同步”的方式处理有限/有限持续时间的可观察序列，例如整理所有传入值，然后通过处理承诺呈现一次

---

实际上，您可以对每个值以及错误和完成事件以任何方式进行操作。因此，最重要的功能差异是无法取消承诺。

我只是回顾了最新的可用代码，从技术上讲，foreach的代码实际上是在RxScala、RxJS和RxJava中调用subscribe。这似乎没有什么大的不同。它们现在有一个返回类型，允许用户有一种停止订阅或类似内容的方法

当我在RxJava早期版本上工作时，订阅有一个订阅返回，而forEach只是一个空白。由于这些变化，您可能会看到一些不同的答案

/**
 * Subscribes to the [[Observable]] and receives notifications for each element.
 *
 * Alias to `subscribe(T => Unit)`.
 *
 * $noDefaultScheduler
 *  
 * @param onNext function to execute for each item.
 * @throws java.lang.IllegalArgumentException if `onNext` is null
 * @throws rx.exceptions.OnErrorNotImplementedException if the [[Observable]] tries to call `onError`
 * @since 0.19
 * @see <a href="http://reactivex.io/documentation/operators/subscribe.html">ReactiveX operators documentation: Subscribe</a>
 */
def foreach(onNext: T => Unit): Unit = {
    asJavaObservable.subscribe(onNext)
 }

def subscribe(onNext: T => Unit): Subscription = {
    asJavaObservable.subscribe(scalaFunction1ProducingUnitToAction1(onNext))
}

/**
 *  Subscribes an o to the observable sequence.
 *  @param {Mixed} [oOrOnNext] The object that is to receive notifications or an action to invoke for each element in the observable sequence.
 *  @param {Function} [onError] Action to invoke upon exceptional termination of the observable sequence.
 *  @param {Function} [onCompleted] Action to invoke upon graceful termination of the observable sequence.
 *  @returns {Disposable} A disposable handling the subscriptions and unsubscriptions.
 */
observableProto.subscribe = observableProto.forEach = function (oOrOnNext, onError, onCompleted) {
  return this._subscribe(typeof oOrOnNext === 'object' ?
    oOrOnNext :
    observerCreate(oOrOnNext, onError, onCompleted));
};

/**
 * Subscribes to the {@link Observable} and receives notifications for each element.
 * <p>
 * Alias to {@link #subscribe(Action1)}
 * <dl>
 *  <dt><b>Scheduler:</b></dt>
 *  <dd>{@code forEach} does not operate by default on a particular {@link Scheduler}.</dd>
 * </dl>
 * 
 * @param onNext
 *            {@link Action1} to execute for each item.
 * @throws IllegalArgumentException
 *             if {@code onNext} is null
 * @throws OnErrorNotImplementedException
 *             if the Observable calls {@code onError}
 * @see <a href="http://reactivex.io/documentation/operators/subscribe.html">ReactiveX operators documentation: Subscribe</a>
 */
public final void forEach(final Action1<? super T> onNext) {
    subscribe(onNext);
}

public final Disposable forEach(Consumer<? super T> onNext) {
    return subscribe(onNext);
}

/**
*订阅[[Observable]]并接收每个元素的通知。
*
*别名为'subscribe（T=>Unit）`。
*
*$noDefaultScheduler
*  
*@paramonnext函数为每个项目执行。
*@onNext为空时抛出java.lang.IllegalArgumentException
*@throws rx.exceptions.OnErrorNotImplementedException，如果[[Observable]]尝试调用'onError]`
*@自0.19起
*@见
*/
def foreach（onNext:T=>单位）：单位={
asJavaObservable.subscribe（onNext）
}
def订阅（onNext:T=>单位）：订阅={
asJavaObservable.subscribe（scalaFunction1ProducingUnitToAction1（onNext））
}
/**
*给可观测序列标上一个o。
*@param{Mixed}[oOrOnNext]为可观察序列中的每个元素接收通知或调用操作的对象。
*@param{Function}[onError]在可观察序列异常终止时调用的操作。
*@param{Function}[onCompleted]在可观察序列优雅终止时调用的操作。
*@返回{Disposable}一个处理订阅和取消订阅的一次性文件。
*/
observableProto.subscribe=observableProto.forEach=函数（oOrOnNext，onError，onCompleted）{
返回此。\u subscribe（oOrOnNext的类型=='object'？
oOrOnNext：
observer创建（oOrOnNext、onError、onCompleted））；
};
/**
*订阅{@link Observable}并接收每个元素的通知。
*
*{@link#subscribe（Action1）的别名
* 
*调度程序：
*默认情况下，{@code forEach}不会在特定的{@link Scheduler}上运行。
* 
* 
*@paramonnext
*{@link Action1}为每个项目执行。
*@galargumentException
*如果{@code onNext}为空
*@OnErrorNotImplementedException
*如果可观察对象调用{@code onError}
*@见
*/
public final void forEach（final actions 1因为forEach没有返回subscribe的结果，不同的是返回值。这意味着您不能取消通过调用forEach启动的“订阅”。感谢您指出。这是他们在最近的代码中更新的部分，我只是相应地更新了我的答案。“在RxJS 5.0遵循的ES7规范（但RxJS 4.0不遵循）中，这两个规范是不一样的。”注意到规范会随着时间的推移而变化是非常重要的。这很烦人，所以现在它是正确的，可能过去不是或者将来不会是。所以正确的答案总是要指定什么的版本（这一个有）.对于forEach，我们需要取消订阅还是它自己处理？@SamiullahKhan：你的问题需要比回答“是/否”更复杂。
forEach在内部订阅，然后返回一个承诺；有了这个承诺，你就无法取消订阅。然而，你也无法取消，所以你可能认为它会完成可观察库的传统设计期望是，
取消订阅
在
完成
或
错误
时自动发生。因此，如果
forEach
在概念上对您有效，则不需要取消订阅。
forEach
不
Unssubscribe
但
完成
和
错误
执行。因此，据我所知，
forEach
对于
等待obs.forEach（doSomething）之类的操作非常有用
，方法将在可观察对象完成后完成。另一方面，当观察对象的生存期可能短于可观察对象的生存期时，您将使用
.subscribe（）
和相应的
.unsubscribe（）
。