Question

我对Reactive Programming很新，但已经恋爱了。然而，仍然很难改变我的大脑。我试图遵循所有建议，如“避免使用主题”和“避免不纯的功能”，当然“避免使用命令式代码。”

我发现难以实现的是简单的交叉模块通信，其中一个模块可以注册“动作”/可观察，另一个模块可以订阅并对其做出反应。一个简单的消息总线可能会工作，但这将强制使用主题和命令式代码风格，我试图避免。

所以这是我正在玩的一个简单的起点：

    // some sandbox
class Api {
  constructor() {
    this.actions = {};
  }

  registerAction(actionName, action) {
    // I guess this part will have to be changed
    this.actions[actionName] = action.publishReplay(10).refCount();
    //this.actions[actionName].connect();
  }

  getAction(actionName) {
    return this.actions[actionName];
  }
}

const api = new Api();

// -------------------------------------------------------------------
// module 1
let myAction = Rx.Observable.create((obs) => {
  console.log("EXECUTING");
  obs.next("42 " + Date.now());
  obs.complete();
});

api.registerAction("myAction", myAction);

let myTrigger = Rx.Observable.interval(1000).take(2);

let executedAction = myTrigger
.flatMap(x => api.getAction("myAction"))
.subscribe(
  (x) => { console.log(`executed action: ${x}`); },
  (e) => {}, 
  () => { console.log("completed");});

// -------------------------------------------------------------------
// module 2
api.getAction("myAction")
  .subscribe(
  (x) => { console.log(`SECOND executed action: ${x}`); },
  (e) => {}, 
  () => { console.log("SECOND completed");});

所以目前第二个模块订阅它“触发”“myAction”Observable。在现实生活中，这可能是一个ajax调用。有没有办法让所有用户延迟/等待，直到从module1正确调用“myAction”？再次 - 使用主题很容易做到，但我正在尝试按照推荐的做法。

Answer 1

如果我理解正确，你要确保，如果你调用api.getAction，你希望该observable中的下一个值等到对getAction的调用完成。在处理其他值之前。

使用concatMap可以很容易地实现这一点。 ConcatMap将采用一个返回observable的函数（在您的情况下调用getAction）。 ConcatMap将等待开始处理下一个值，直到函数中返回的observable完成。

因此，如果您更改这样的代码，它应该有效（如果我理解正确的话）。

let executedAction = myTrigger
.concatMap(x => api.getAction("myAction"))
.subscribe(
  (x) => { console.log(`executed action: ${x}`); },
  (e) => {}, 
  () => { console.log("completed");});

如果myTrigger有一个新值，则在api.getAction返回的observable完成之前不会处理它。

Answer 2

所以这是一个比我想象的更简单的解决方案。只需使用2个可观察量即可。使用调度程序和subscribeOn可以实现类似的效果。

    // some sandbox
class Action {
  constructor(name, observable) {
    this.name = name;
    this.observable = observable;
    this.replay = new Rx.ReplaySubject(10);
  }
}

function actionFactory(action, param) {

  return Rx.Observable.create(obs => {
    action.observable
    .subscribe(x => {
        obs.next(x);
        action.replay.next(x);
    }, (e) => {}, () => obs.complete);
  }); 
}

class Api {
  constructor() {
    this.actions = {};
  }

  registerAction(actionName, action) {
    let generatedAction = new Action(actionName, action);

    this.actions[actionName] = generatedAction;

    return actionFactory.bind(null, generatedAction);
  }

  getAction(actionName) {
    return this.actions[actionName].replay;
  }
}

const api = new Api();

// -------------------------------------------------------------------
// module 1
let myAction = Rx.Observable.create((obs) => {
  obs.next("42 " + Date.now());
  obs.complete();
});

let myRegisteredAction$ = api.registerAction("myAction", myAction);

let myTrigger = Rx.Observable.interval(1000).take(1).delay(1000);

let executedAction = myTrigger
.map(x => { return { someValue: x} })
.concatMap(x => myRegisteredAction$(x))
.subscribe(
  (x) => { console.log(`MAIN: ${x}`); },
  (e) => { console.log("error", e)}, 
  () => { console.log("MAIN: completed");});


// -------------------------------------------------------------------
// module 2
 var sub = api.getAction("myAction")
  .subscribe(
  (x) => { console.log(`SECOND: ${x}`); },
  (e) => {console.log("error : " + e)}, 
  () => { console.log("SECOND: completed");});

RxJS / ReactiveX正确的模块通信

2 个答案: