如何解决每种情况下开关块的不同承诺,并将其结果传递给相同的功能?

您可以使用一个变量来保持所需resvalue的承诺,就像这样

app.post('/endpoint',function(req,res){
    let reqValue=req.body.value;
    let p;
    switch(reqValue){
         case 'a':
             p = someObj.action_a().then(result => result.id);
             break;
         case 'b':
             p = someObj.action_b().then(result => result.id);
             break;
         default:
             // p has to be a promise, so make it one
             p = Promise.resolve("default");
    }
    p.then(resValue => {
        doSomethingElse();
        res.end(resValue);
    });
});

或者使用现代的javascript,使用async/await

app.post('/endpoint',async function(req,res){
    let reqValue=req.body.value;
    let resValue="initial value";
    switch(reqValue){
         case 'a':
             resValue = await someObj.action_a().then(result => result.id);
             break;
         case 'b':
             resValue = await someObj.action_b().then(result => result.id);
             break;
         default:
             resValue = "default";
    }
    doSomethingElse();
    res.end(resValue);
});

如果你能使用javascript的新功能,我建议你 async 和 await 因为它们易于阅读和使用,所以您的代码将更改为:

let resValue = "default";
switch (reqValue) {
  case 'a':
    resValue = (await someObj.action_a()).id;
    break;
  case 'b':
    resValue = (await someObj.action_b()).id;
    break;
  default:
    break;
}
doSomethingElse();
res.end(resValue);

相反,您可以创建一个通用函数,该函数根据给定的操作类型返回数据,并具有 switch 然后在主函数中使用一个简单的async/await来等待

// Made up function that switches action
// based on the type (in this case the timer on the
// setTimeout)
function doAction(type) {
  let time;
  switch(type) {
    case 'a': time = 1000; break;
    case 'b': time = 2000; break;
    case 'c': time = 300; break;
  }
  return new Promise(resolve => {
    setTimeout(() => resolve({ id: `${type}1` }), time);
  });
}

async function main(type) {
  try {

    // Pass in the type to the doAction function,
    // let that decide what to do, and await the promise
    // to resolve
    const result = await doAction(type);

    // Then just console.log or res.send the result 
    const resValue = result.id;
    console.log(resValue);
  } catch (e) {
    console.log(e);
  }
}

main('b');
main('a');
main('c');

如果你不能使用,这里有一个选项 async/await 相反,必须坚持 Promises (但是,如果有很多情况,嵌套的三元可能会变得不雅观;请继续阅读,了解不同的想法):

app.post('/endpoint', function(req, res) {
  const reqValue = req.body.value;
  (reqValue === 'a'
    ? someObj.action_a().then(({id}) => id)
    : reqValue === 'b'
      ? someObj.action_b.then(({id}) => id)
      : Promise.resolve('default'))
        .then(resValue => {
          doSomethingElse();
          res.end(resValue);
        });
});

相反,假设您将操作存储在 Object :

const actions = {
  a: () => someObj.action_a();
  b: () => someObj.action_b();
  // ...
  n: () => someObj.action_n();
};

app.post('endpoint', function(req, res) {
  const action = actions[req.body.value];
  (action && action().then(({id}) => id) || Promise.resolve('default'))
    .then(resValue => {
      doSomethingElse();
      res.end(resValue);
    });
});

Promise.all 是一个非常方便的工具,用于跟踪所有子承诺的任务

const jobqQeue = [];

switch(...) {
  case: '...': {
    jobqQeue.push(
      subPromise()
    );
  }
  case: '...': {
    jobqQeue.push(
      subPromise2()
    );
  }
  default: {
    jobqQeue.push(
      defaultOpPromise();
    );
  }
}

Promise.all(jobqQeue)
.then(results => {
  ...
})
.catch(error => console.error(error));