Javascript RxJS：将承诺结果和承诺错误映射到不同的值

以下代码有效地将承诺解析映射为

true

，将承诺错误映射为

false

onlineUpdate$
.switchMap(online => {
  switch (online) {
    default:
    case true: {
      const connected$ = new Rx.Subject();
      axios.get("/some/url/to/test/connection")
        .then(response => connected$.next(true))
        .catch(error => connected$.next(false));
      return connected$;
    }
    case false: {
      return Rx.Observable.of(false);
    }
  }
});

---

但是关于创建中间

Rx.Subject

的一些事情感觉我做了比我需要做的更多的工作。是否有一种更优雅或内置的方法，可以将承诺解析映射到一个值，并将承诺错误映射到另一个值，而无需使用中间

Rx.Subject

或其他可观察到的对象？

通过函数将承诺包装成可观察的，并将承诺传递到。如果承诺得到解决，Observable将发出

true

；如果承诺被拒绝，Observable将发出

false

...
case true: {
      return Rx.Observable.fromPromise(axios.get("/some/url/to/test/connection")
                                            .then(response => true)
                                            .catch(error => false));
    }
...

简单的例子

Rx.Observable.of（false

）等同于

案例false

。

Promise.resolve（true）

到Promise的

函数，然后
到Promise.reject（'Error'）。catch（err=>false）
到Promise的
catch
函数


Rx.Observable.of（false）.subscribe（console.log）；
Rx.Observable.fromPromise（Promise.resolve（true））.subscribe（console.log）；
Rx.Observable.fromPromise（Promise.reject（'Error'）.catch（err=>false））.subscribe（console.log）
将承诺封装到可观察的via函数中，并将承诺传递到。如果承诺得到解决，Observable将发出
true
；如果承诺被拒绝，Observable将发出
false

...
case true: {
      return Rx.Observable.fromPromise(axios.get("/some/url/to/test/connection")
                                            .then(response => true)
                                            .catch(error => false));
    }
...

简单的例子

Rx.Observable.of（false
）等同于
案例false
。
Promise.resolve（true）
到Promise的
函数，然后
到Promise.reject（'Error'）。catch（err=>false）
到Promise的
catch
函数


Rx.Observable.of（false）.subscribe（console.log）；
Rx.Observable.fromPromise（Promise.resolve（true））.subscribe（console.log）；
Rx.Observable.fromPromise（Promise.reject（'Error'）.catch（err=>false））.subscribe（console.log）
是的，您可以在
Observable.fromPromise（）的catch块中返回
Observable.of（false）
。与wise一样，如果连接成功，使用
.map（）
返回
可观察的.of（true）

onlineUpdate$
    .switchMap(online => {
        switch (online) {
            default:
            case true: {
                Rx.Observable.fromPromise(axios.get("/some/url/to/test/connection"))
                    .map(() => true) // if the promise resolves to something, return an Observable.of(true)
                    .catch(() => Rx.Observable.of(false)) // else if there is any error return Observable.of(false)
            }
            case false: {
                return Rx.Observable.of(false);
            }
        }
    });

请注意，如果
承诺
成功解析，则必须显式地
.map（）
可观察的
从承诺
转换为true

您可以用更简洁的方式编写代码：

onlineUpdate$
    .switchMap(online => {
        return online ?
            Rx.Observable.fromPromise(axios.get("/some/url/to/test/connection"))
                .map(() => true)
                .catch(() => Observable.of(false))
            : Observabe.of(false)
    });

是的，您可以在
Observable.fromPromise（）
的catch块中返回
Observable.of（false）
。与wise一样，如果连接成功，使用
.map（）
返回
可观察的.of（true）

onlineUpdate$
    .switchMap(online => {
        switch (online) {
            default:
            case true: {
                Rx.Observable.fromPromise(axios.get("/some/url/to/test/connection"))
                    .map(() => true) // if the promise resolves to something, return an Observable.of(true)
                    .catch(() => Rx.Observable.of(false)) // else if there is any error return Observable.of(false)
            }
            case false: {
                return Rx.Observable.of(false);
            }
        }
    });

请注意，如果
承诺
成功解析，则必须显式地
.map（）
可观察的
从承诺
转换为true

您可以用更简洁的方式编写代码：

onlineUpdate$
    .switchMap(online => {
        return online ?
            Rx.Observable.fromPromise(axios.get("/some/url/to/test/connection"))
                .map(() => true)
                .catch(() => Observable.of(false))
            : Observabe.of(false)
    });

switchMap
操作符使用所谓的函数，这意味着您可以返回承诺，而不将其转换为可观察的：

onlineUpdate$
.switchMap(online => {
  switch (online) {
    default:
    case true: {
      return axios.get("/some/url/to/test/connection");
    }
    case false: {
      return Rx.Observable.of(false);
    }
  }
})
.catch(() => Rx.Observable.of(false))
.map(Boolean) // force convert to boolean

要知道这和你写的不一样。
catch
操作符将捕获所有错误，即使它们不是来自前面的
axios.get
调用，但在您的情况下，这可能无关紧要。
switchMap
操作符处理所谓的错误，这意味着您可以返回承诺而不将其变成可观察的：

onlineUpdate$
.switchMap(online => {
  switch (online) {
    default:
    case true: {
      return axios.get("/some/url/to/test/connection");
    }
    case false: {
      return Rx.Observable.of(false);
    }
  }
})
.catch(() => Rx.Observable.of(false))
.map(Boolean) // force convert to boolean

要知道这和你写的不一样。
catch
操作符将捕获所有错误，即使它们不是来自前面的
axios.get
调用，但在您的情况下，这可能并不重要。
事实证明根本不需要使用
observeable.fromPromise（）
。实现这一目标最直接的改变是：

onlineUpdate$
.switchMap(online => {
  switch (online) {
    default:
    case true: {
      return axios.get("/some/url/to/test/connection")
        .then(response => true)
        .catch(error => false);
    }
    case false: {
      return Rx.Observable.of(false);
    }
  }
});

或者，如果您更喜欢ternaries而不是
switch
语句：

onlineUpdate$
.switchMap(online => {
  return online ?
    axios.get("/some/url/to/test/connection")
      .then(response => true)
      .catch(error => false)
    : Rx.Observable.of(false);
});

原来根本不需要使用
Observable.fromPromise（）
。实现这一目标最直接的改变是：

onlineUpdate$
.switchMap(online => {
  switch (online) {
    default:
    case true: {
      return axios.get("/some/url/to/test/connection")
        .then(response => true)
        .catch(error => false);
    }
    case false: {
      return Rx.Observable.of(false);
    }
  }
});

或者，如果您更喜欢ternaries而不是
switch
语句：

onlineUpdate$
.switchMap(online => {
  return online ?
    axios.get("/some/url/to/test/connection")
      .then(response => true)
      .catch(error => false)
    : Rx.Observable.of(false);
});

谢谢你的回答，苏伦。这确实帮助我摆脱了Rx.Subject（）。然而，
flatMap
或
switchMap
不需要使用
Observable.fromPromise
。谢谢你的回答，@Suren。这确实帮助我摆脱了Rx.Subject（）。然而，事实证明，
Observable.fromPromise
在
flatMap
或
switchMap
中是不需要的。虽然在这种特殊情况下不会发生太多事情，但我仍然会，而在这种特殊情况下不会发生太多事情，我仍然会