Question

我正在尝试编写一个（泛型）函数run<ID, ENTITY>(…): Observable<ENTITY>，它接受以下参数：

函数init: () => Observable<ID>，它是启动后端进程的初始化请求。
一个函数status: (id: ID) => Observable<ENTITY>，它获取生成的ID并在后端查询它的状态。
一个函数repeat: (status: ENTITY) => boolean，用于确定是否必须重复status请求。
两个整数值initialDelay和repeatDelay。

因此run应执行init，然后等待initialDelay秒。从现在开始，它应该每status秒运行repeatDelay，直到repeat()返回false。

但是，有两件重要的事情需要发挥作用：

repeatDelay只应在status发出其值时开始计算，以便在status花费的时间超过repeatDelay时避免竞争条件
调用status所发出的中间值也必须发送给调用者。

以下（不是非常漂亮）版本除了我提到的最后一件事之外还会执行所有操作：在重试status之前，它不会等待网络响应。

run<ID, ENTITY>(…): Observable<ENTITY> {
    let finished = false;
    return init().mergeMap(id => {
        return Observable.timer(initialDelay, repeatDelay)
            .switchMap(() => {
                if (finished) return Observable.of(null);
                return status(id);
            })
            .takeWhile(response => {
                if (repeat(response)) return true;
                if (finished) return false;

                finished = true;
                return true;
            });
    });
}

我的第二个版本是这个，除了一个细节之外，它再次适用于所有细节：status调用的中间值不会被发出，但我确实需要它们在调用者中显示进度：

run<ID, ENTITY>(…): Observable<ENTITY> {
    const loop = id => {
        return status(id).switchMap(response => {
            return repeat(response)
                ? Observable.timer(repeatDelay).switchMap(() => loop(id))
                : Observable.of(response);
        });
    };

    return init()
        .mergeMap(id => Observable.timer(initialDelay).switchMap(() => loop(id)));
}

不可否认，后者也是一个不错的选择。我确信rxjs可以用更简洁的方式解决这个问题（更重要的是，完全解决它），但我似乎无法弄清楚如何。

Answer 1

更新：Observable支持expand原生的递归，也在@IngoBürk的回答中显示。这让我们可以更简洁地编写递归：

function run<ENTITY>(/* ... */): Observable<ENTITY> {
  return init().delay(initialDelay).flatMap(id =>
    status(id).expand(s => 
      repeat(s) ? Observable.of(null).delay(repeatDelay).flatMap(_ => status(id)) : Observable.empty()
    )
  )
}

Fiddle.

如果递归是可以接受的，那么你可以更简洁地做事：

function run(/* ... */): Observable<ENTITY> {
  function recurse(id: number): Observable<ENTITY> {
    const status$ = status(id).share();
    const tail$ = status$.delay(repeatDelay)
                         .flatMap(status => repeat(status) ? recurse(id, repeatDelay) : Observable.empty());
    return status$.merge(tail$);
  }
  return init().delay(initialDelay).flatMap(id => recurse(id));
}

尝试the fiddle。

Answer 2

repeatWhen运算符本身看起来很诱人，但它只提供onComplete通知的无效流，因此您无法在没有外部帮助的情况下根据值重复。在这里，BehaviorSubject可能是您最好的选择：

function run(/* ... */): Observable<ENTITY> {
  const last_value$ = new BehaviorSubject();
  const delayed$ = init()
    .delay(initialDelay)
    .flatMap(id => 
      status(id).repeatWhen(completions => 
         completions.delay(repeatDelay)
                    .takeWhile(_ => repeat(last_value$.getValue()))
      )
    ).share();
  delayed$.subscribe(last_value$);
  return delayed$;
}

此处，repeatWhen仅重新订阅请求的冷源，如果上一个请求的最后一个值是表示重复的状态。

Try the fiddle.

警告：当repeatDelay在执行的通知程序（传递给repeatWhen的函数）和接收相应状态的BehaviorSubject之间很小时，可能存在竞争条件风险。对于给定的观察者，我们保证在onNext通知之前发生所有onCompleted次通知，但我们的BehaviorSubject和repeatWhen已分开。乍看the source，看起来onNext通知正好通过repeatWhen。我怀疑对concat也是如此，但我不确定。

Answer 3

所以我想出了这个似乎有效的方法。它使用expand创建无限重试序列，并使用takeWhile来确定从中获取的时间。

可以通过编写使用谓词函数的自定义运算符takeWhile来删除takeUntil hack。目前不存在，请参阅rxjs#2420。

小提琴：https://jsfiddle.net/2mhcvnog/1/

run<ID, ENTITY>(...): Observable<ENTITY> {
    /* This little hack is needed to also emit the final item in the takeWhile() loop. */
    let finished = false;

    const delayStatus = (id, delay) => {
        return Observable.of(null)
            .delay(delay)
            .switchMap(() => status(id))
            .map(status => [id, status]);
    };

    return init()
        .mergeMap(id => delayStatus(id, initialDelay))
        .expand(([id]) => {
            if (finished) {
                return Observable.of([id, null]);
            }

            return delayStatus(id, repeatDelay);
        })
        .takeWhile(([_, status]) => {
            if (repeat(status)) {
                return true;
            }

            if (finished) {
                return false;
            }

            finished = true;
            return true;
        })
        .map(([_, status]) => status);
}

重复请求直到满足条件并返回中间值

3 个答案: