Ветвление и (пере) объединение пар значений в RxJS

Это довольно сложная проблема для решения, и именно то, как вы это сделаете, будет зависеть от очень конкретных деталей вашего используемого случая, которые не были включены.

Тем не менее, здесь один из возможных способов, который делает кучу допущений. Он был несколько общим, как пользовательский оператор, который можно использовать с let.

(примечание стороны: я назвал это "сопоставить", но это плохое и очень вводящее в заблуждение имя для этого, но не имеет времени, чтобы называть вещи...)

const collate = (...segments) => source$ =>
  source$
    .mergeMap((obj, index) => {
      return segments.map(({ key, work }) => {
        const input = obj[key];
        const output$ = work(input);

        return Observable.from(output$).map(output => ({
          index,
          result: { [key]: output }
        }))
      })
    })
    .mergeAll()
    .groupBy(
      obj => obj.index,
      obj => obj.result,
      group$ => group$.skip(segments.length - 1)
    )
    .mergeMap(group$ =>
      group$.reduce(
        (obj, result) => Object.assign(obj, result),
        {}
      )
    );

И вот пример использования:

const result$ = input$.let(
  collate({
    key: 'a',
    work: a => {
      // do stuff with "a"
      return Observable.of(a).map(d => d + '-processed-A');
    }
  }, {
    key: 'b',
    work: b => {
      // do stuff with "b"
      return Observable.of(b).map(d => d + '-processed-B');
    }
  })
);

Учитывая входные данные { a: '1', b: '1 } он выдаст { a: '1-processed-A', b: '1-processed-B' } и т.д., Сгруппированные правильно, делая столько же одновременно, сколько возможно - единственная буферизация, которую он выполняет, - это сопоставление всех сегментов для конкретного ввода.

Здесь работает демонстрационная версия https://jsbin.com/yuruvar/edit?js,output

Сломать

Там, вероятно, более понятные/более простые способы сделать это, особенно если вы можете жестко кодировать некоторые вещи, а не создавать их общие. Но пусть разбивает то, что я сделал.

const collate = (...segments) => source$ =>
  source$
    // for every input obj we use the index as an ID
    // (which is provided by Rx as autoincrementing)
    .mergeMap((obj, index) => {
      // segments is the configuration of how we should
      // chunk our data into concurrent processing channels.
      // So we're returning an array, which mergeMap will consume
      // as if it were an Observable, or we could have used
      // Observable.from(arr) to be even more clear
      return segments.map(({ key, work }) => {
        const input = obj[key];
        // the 'work' function is expected to return
        // something Observable-like
        const output$ = work(input);

        return Observable.from(output$).map(output => ({
          // Placing the index we closed over lets us later
          // stitch each segment back to together
          index,
          result: { [key]: output }
        }))
      })
    })
    // I had returned Array<Observable> in mergeMap
    // so we need to flatten one more level. This is
    // rather confusing...prolly clearer ways but #YOLO
    .mergeAll()
    // now we have a stream of all results for each segment
    // in no guaranteed order so we need to group them together
    .groupBy(
      obj => obj.index,
      obj => obj.result,
      // this is tough to explain. this is used as a notifier
      // to say when to complete() the group$, we want complete() it
      // after we've received every segment for that group, so in the
      // notifier we skip all except the last one we expect
      // but remember this doesn't skip the elements downstream!
      // only as part of the durationSelector notifier
      group$ => group$.skip(segments.length - 1)
    )
    .mergeMap(group$ =>
      // merge every segment object that comes back into one object
      // so it has the same shape as it came in, but which the results
      group$.reduce(
        (obj, result) => Object.assign(obj, result),
        {}
      )
    );

Я не думал и не беспокоился о том, как обработка ошибок/распространение может работать, потому что это сильно зависит от вашего usecase. Если у вас нет контроля над обработкой каждого сегмента, то также можно .take(1) какой-то тайм-аут и .take(1), иначе вы можете пропустить подписки.