Question

我有一个条件语句，我需要执行两个操作之一，然后在解决了哪个操作后继续。所以我的代码目前看起来如下：

if (shoud_do_thing_a) { //should_do_thing_a is just a variable that determines which function to call. it is not a promise
  do_thing_a()
} else {
  do_thing_b()
}

// more code

问题是do_thing_a和do_thing_b都会返回承诺，我无法继续前进，直到执行哪个已经解决。我想出来解决这个问题的最好方法就是这样：

var more_code = function () { 
  // more code
}

if (shoud_do_thing_a) {
  do_thing_a().then(more_code)
} else {
  do_thing_b().then(more_code)
}

我不喜欢这种结构。这很难理解，因为你需要跳转到找到more_code定义的位置（想象我在几个地方有这种类型的控制流），而不是简单地继续阅读。

有没有更好的方法在javascript中处理这类事情？

Answer 1

或者：

var more_code = function () { 
    // more code
}

var do_thing;
if (shoud_do_thing_a) {
  do_thing = do_thing_a()
} else {
  do_thing = do_thing_b()
}

do_thing.then(more_code)

如果您可以使用async / await

async function someFunc() {
    var more_code = function () { 
        // more code
    }

    if (shoud_do_thing_a) {
        await do_thing_a()
    } else {
        await do_thing_b()
    }

    more_code()
}

Answer 2

如果您坚持使用原始Promise并且无法使用async/await（您通常应该没有问题，使用babel /打字稿等），以下内容比存储更优雅变量中的承诺：

function something() {
  return Promise.resolve()
    .then(() => {
      if (should_do_thing_a) {
        return do_thing_a();
      }
      else if (should_do_thing_b) {
        return do_thing_b();
      }
    })
    .then(some_more_code);
}

请注意，当您开始使用Promises时，您的函数应始终返回其他函数可以使用的Promise。保留异步操作而无需任何方法来处理它意味着糟糕的事情，特别是在处理错误时。

从更一般的意义上讲，这意味着当你使用Promises时，你的更多代码就会被提升＃34;被执行并作为承诺归还。

Answer 3

我想如何改进其他答案：

保持干净简洁
没有不必要的变量
返回承诺asap
在js中我们使用camelCase
将它放在一个函数中并命名该函数以保持其可读性
让then执行moreCode，以便在事情完成后调用。

function doTheThing () {
  if (shouldDoA) return doThingA()
  else return doThingB()
}

doTheThing().then(moreCode)

Answer 4

保存承诺并在if语句后添加then：

var promise;

if (shoud_do_thing_a) {
  promise = do_thing_a();
} else {
  promise = do_thing_b();
}

promise.then(more_code);

Answer 5

var promise = shoud_do_thing_a? do_thing_a: do_thing_b

promise().then(function () {
// more code    
})

Answer 6

与此处的其他答案类似，但您可以自行执行异步并稍微清理一下条件。

(async () => {
  const should_do_thing_a = true

  const do_thing_a = function() {
    return new Promise(function(resolve, reject) {
      resolve('a')
    })
  }

  const do_thing_b = function() {
    return new Promise(function(resolve, reject) {
      resolve('b')
    })
  }

  const result = (should_do_thing_a) ? await do_thing_a() : await do_thing_b()

  console.log(result)

})()

Answer 7

我这样做的方法是将if检查放入另一个返回promise的函数中。通过if-else语句中其他函数调用的解析，可以解决promise。

示例：

function performCheck(condition) {
    var defer = $q.defer();
    if (condition) {
        doThingA().then(function(response) {
            defer.resolve(response);
        });
    } else {
        doThingB().then(function(response) {
            defer.resolve(response)
        });
    }
    return defer.promise;
}
performCheck(condition).then(function(response) {
    //Do more code.
});

在我看来，我更喜欢这种方法，因为现在可以在多个地方使用此功能，您可以检查条件，减少代码重复，并且更容易理解。

您可以使用

进一步降低此值

function performCheck(condition) {
    var defer = $q.defer();
    var doThisThing = condition ? doThingA : doThingB;
    doThisThing().then(function (response) {
        defer.resolve(response);
    });
    return defer.promise;
}
performCheck(condition).then(function(response) {
    //Do more code.
});

Answer 8

简单的工作示例：

其定义的范围必须是异步。

const createUser = async (data) => {
   if (await isUsernameTaken(username)) { return 'username-taken' }
}

isUsernameTaken函数：

const isUsernameTaken = async (username) => {
    const request = await API.SomeRequest
    return !request.isEmpty
}

Answer 9

您可以使用async/await

async function fn() {
  let p, result;
  if (shoud_do_thing_a) {
    p = await do_thing_a()
  } else {
    p = await do_thing_b()
  }
  if (p) {
    result = more_code();
  }
  return result
}

Answer 10

more_code = miFunc() => return new Promise((resolve, reject) => ... });

解决方案1

const waitFor = should_do_thing_a ? do_thing_a() : do_thing_b();
waitFor.then(...).catch(...)

解决方案2

let waitFor = Promise.resolve();

if (do_thing_a) {
    waitFor = do_thing_a();
} else {
    waitFor = do_thing_b();
}

waitFor.then(...).catch(...);

使用if / else中的promise

10 个答案: