我应该在每个类方法中创建一个新的 Promise 吗？

Question

我想在我的类方法中使用 Promises。在Promise antipatterns 中，我读到为每个新功能创建一个新的承诺被认为是不好的。

但是，我不想在我的项目中返回不相关的承诺，所以我想做这样的事情：

class MyClass {

  async getToken() {
    return new Promise(
      (resolve, reject) => {
        // . . .
        const token_str = '<response_from_http_request>';
        resolve(token_str);
      }
    )
  }

  async doSomething(token) {
    return new Promise(
      (resolve, reject) => {
        const result = // . . .
        resolve(result);
      }
    )
  }

  async doAnotherSomething(token) {
    return new Promise(
      (resolve, reject) => {
        const result = // . . .
        resolve(result);
      }
    )
  }

}

然后我会这样使用它：

let instance = new MyClass();

(async () => {
    const token = await instance.getToken();

    const result1 = await instance.doSomething(token);
    console.log(result1);

    const result2 = await instance.doAnotherSomething(token);
    console.log(result2);

})();

这似乎是一种有效的方法，或者这也是一种反模式？如果是这样，我怎样才能避免编写这样的代码？

---

编辑：如果我需要进行多次连续的 http 调用，对结果执行一些操作，然后基于它返回一个 Promise？

按照我的理解，如果我不做出新的承诺，我必须返回got.js库做出的承诺，其中包括http响应数据。

相反，我想返回一个包含我的类方法结果的 Promise。

例子：

  async getCityWeather( city_name ) {
    return new Promise(
      (resolve, reject) => {

        // get the city id based on its name
        const city_id = await got(`https://my-api/getCityIdByName/${city_name}`);

        // now get the weather info for the city with id `cityid`
        const weather_info = await got(`https://my-api/weatherById/${city_id}`);

        // make an object to return
        const temperature = {
          weather_info.temp_min,
          weather_info.temp_max,
        }

        resolve(temperature);

        // ... all error handling are omitted

      }
    )
  }

我不想返回包含 got.js 返回值的 Promise，我想根据 http 请求调用返回 my 值。

Answer 1

async 函数总是返回Promise。

一个函数/方法在以下情况下会返回一个Promise：

• 您显式创建并从其主体返回了一个 Promise。
• 您返回了一个存在于方法之外的 Promise。
• 您将其标记为async。

由于您可以 await 一个 Promise 并且 instance.doSomething 已经是一个异步标记的方法，您可以等待它而无需显式返回一个 Promise。

只需return，它的结果就像您在常规同步方法中一样。

我不想在我的项目中返回不相关的承诺...

除非您实际上在方法中执行异步操作（访问文件系统、数据库调用、计时器等...），否则您不需要将其包装在 Promise 中, 也不是 await 当您需要结果时。

您实际上需要在Promise 中包装某些内容的最常见情况是，如果您有一个使用callbacks 工作的异步函数，但您想将其用作Promise。

// plain old callback-style asynchronous functions:
const getFooViaCallback = callback => {
  setTimeout(() => {
    callback('foo')
  }, 150)
}

const getBarViaCallback = callback => {
  setTimeout(() => {
    callback('bar')
  }, 150)
}

class Foo {
  constructor() {}
  
  getFooViaPromise() {
    // wrap callback-style code in a Promise
    // so we can await it.
    return new Promise(resolve => {
      getFooViaCallback(result => {
        resolve(result)
      })
    })
  }

  getBarViaPromise() {
    // wrap callback-style code in a Promise
    // so we can await it.
    return new Promise(resolve => {
      getBarViaCallback(result => {
        resolve(result)
      })
    })
  }
  
  getBaz() {
    // no reason to wrap this in a Promise,
    // since it's a synchronous method.
    return 'baz'
  }
  
  async getFooBarBaz() {
    const foo = await this.getFooViaPromise()
    const bar = await this.getBarViaPromise()
    const baz = this.getBaz()

    return foo + ',' + bar + ',' + baz
  }
}

;(async() => {
  const foo = new Foo()
  
  const result = await foo.getFooBarBaz()
  console.log('foo.getFooBarBaz() result: ', result)
})()

为简洁起见，我在上面的 sn-p 中省略了错误处理，但您应该在 async 标记的方法中使用 throw 来引发错误。这相当于在 Promise 中调用 .reject()。