Javascript ECMAScript 2015调用

我正试图重写一个同步连接来实现承诺，我有点被它卡住了。我有一个函数，根据参数和结果调用不同的例程

a

、

B

和

C

：

const-worker=（v，r，ok，er）=>{
如果（v>10）{
ok（r）
}否则{
er（r）
}
};
常量A=v=>{let r=null；worker（v，'A'，_r=>r=\u r，（）=>{}）；返回r}；
常量B=v=>{let r=null；worker（v，'B'，_r=>r=\u r，（）=>{}）；返回r}；
const C=v=>{let r=null；worker（v，'C'，_r=>r=\u r，（）=>{}）；返回r}；
常量mainSync=（对象）=>{
设result=null；
国际单项体育联合会（obj.a）{
结果=A（目标A）；
}
if（！result&&obj.b）{
结果=B（目标B）；
}
if（！result&&obj.c）{
结果=C（对象C）；
}
返回结果；
}

与同步

A

、

B

和

C

配合使用时效果良好：

mainSync（{a:4}）==null；
mainSync（{a:4，b:14}）='b'；
mainSync（{a:14，b:14}）='a'；
mainSync（{b:4，c:14}）='c'；
//等

现在，

A

、

B

和

C

成为承诺：

const-worker=（v，r，ok，er）=>{
如果（v>10）{
ok（r）
}否则{
er（r）
}
};
const A=v=>新承诺（（好的，呃）=>worker（v'A'，好的，呃））；
const B=v=>新承诺（（好的，呃）=>worker（v'B'，好的，呃））；
const C=v=>newpromise（（好的，呃）=>worker（好的，呃））；

我不太清楚如何处理：

const mainascync=（obj）=>{
//这里该怎么办？
}

我很高兴mainAsync能够返回承诺本身，比如

mainsync（{a:4}）。然后（r=>r==null）；
mainascync（{a:4，b:14}）；
mainaxync（{a:14，b:14}）；
mainascync（{b:4，c:14}）；

问题是对

B

的调用取决于

A

的结果，而对

C

的调用则取决于

A

和

B

的结果，并且还没有

异步/等待

可用

我尝试过我天真的方法，但它很糟糕，在现实生活中不太管用

PS：如果可能的话，我正在寻找香草javascript，我知道类似的问题，比如

• ,
• ,

等等，但不知道如何将它们应用到我的案例中

mainAsync = mainSync;

或者更简单：

function mainAsync({a,b,c}){
  if(c) return C(c);
  if(b) return B(b);
  if(a) return A(a);
}

如果您希望在返回之前完成所有承诺：

function mainAsync({a,b,c}){
 var promises=[];
  if(a) promises.push(A(a));
  if(b) promises.push(B(b));
  if(c) promises.push(C(c));
  return Promise.all(promises).then(val=>val.pop())
}

mainAsync({a:1,b:2,c:3});

或者更简单：

function mainAsync({a,b,c}){
  if(c) return C(c);
  if(b) return B(b);
  if(a) return A(a);
}

如果您希望在返回之前完成所有承诺：

function mainAsync({a,b,c}){
 var promises=[];
  if(a) promises.push(A(a));
  if(b) promises.push(B(b));
  if(c) promises.push(C(c));
  return Promise.all(promises).then(val=>val.pop())
}

mainAsync({a:1,b:2,c:3});

---

根据您试图针对的浏览器类型，您可以使用chrome中的

async/await

功能

函数promiseA（）{return Promise.resolve（20）}
函数promiseB（arg）{returnpromise.resolve（arg*2）}
函数promiseC（arg）{返回承诺.解析（arg+10）}
（异步函数（）{
让a=等待允诺人（）；
控制台日志（a）
let b=等待允诺人b（a）；
控制台日志（b）
让c=等待允诺c（b）；
控制台日志（c）
})();根据您试图针对的浏览器类型，您可以肯定地使用chrome中的
async/await
功能


函数promiseA（）{return Promise.resolve（20）}
函数promiseB（arg）{returnpromise.resolve（arg*2）}
函数promiseC（arg）{返回承诺.解析（arg+10）}
（异步函数（）{
让a=等待允诺人（）；
控制台日志（a）
let b=等待允诺人b（a）；
控制台日志（b）
让c=等待允诺c（b）；
控制台日志（c）
})();
要按顺序调用承诺，可以调用
中的下一个承诺。然后
回调。您的条件（
如果（！result&&…
）很容易转换：

function mainAsync(obj) {
  return (obj.a ? A(obj.a) : Promise.resolve())
    .then(result => !result && obj.b ? B(obj.b) : result)
    .then(result => !result && obj.c ? C(obj.c) : result);
}


如果需要对许多属性执行此操作，则可以通过使用查找表和循环（
Array#reduce
，在本例中）避免重复太多内容：

要按顺序调用承诺，可以调用
回调中的下一个承诺。然后
回调。您的条件（
如果（！result&&…
）很容易转换：

function mainAsync(obj) {
  return (obj.a ? A(obj.a) : Promise.resolve())
    .then(result => !result && obj.b ? B(obj.b) : result)
    .then(result => !result && obj.c ? C(obj.c) : result);
}


如果需要对许多属性执行此操作，则可以通过使用查找表和循环（
Array#reduce
，在本例中）避免重复太多内容：

如果不选择使用ES7 transpilers（用于异步/等待），则可以使用ES2015实现异步控制流。下面是一个简单的示例实现：

function *main() {
  let a = yield Promise.resolve(5);
  let b = yield Promise.resolve(a + 10);
  let c = yield Promise.resolve(b + 15);

  // place the rest of your code here
  console.log(c); // prints 30
}

function execAsync(generator, previousValue) {
  const nextValue = generator.next(previousValue);
  if (!nextValue.done) {
    let promise = nextValue.value;
    // FIXME: promise rejection is not handled
    promise.then(function (value) {
      execAsync(generator, value);
    });
  }
}

// ...    

// start the execution
execAsync(main());

如果不选择使用ES7 transpilers（用于异步/等待），则可以使用ES2015实现异步控制流。下面是一个简单的示例实现：

function *main() {
  let a = yield Promise.resolve(5);
  let b = yield Promise.resolve(a + 10);
  let c = yield Promise.resolve(b + 15);

  // place the rest of your code here
  console.log(c); // prints 30
}

function execAsync(generator, previousValue) {
  const nextValue = generator.next(previousValue);
  if (!nextValue.done) {
    let promise = nextValue.value;
    // FIXME: promise rejection is not handled
    promise.then(function (value) {
      execAsync(generator, value);
    });
  }
}

// ...    

// start the execution
execAsync(main());

请注意，这是ES7（因此它可能不属于ES2015条件）@Jonasw我注意到它有一个节点标记，新版本的node现在支持async/awaitYeah。这一切都很好，只是想指出一下，可能对OPYeah很有用，我还想指出它在新版node中的作用。@Jonasw:
async/await
是ES2017（今年的版本）的一部分，而不是ES7（ES2016）。请注意，这是ES7（因此可能不属于ES2015条件）@Jonasw我注意到这有一个节点标记，新版node现在支持async/await，一切正常，我只是想指出，它可能对操作有用。我想，我还想指出它在node的新版本中。@Jonasw:
async/await
是ES2017（今年的版本）的一部分，而不是ES7（ES2016）。你为什么还要尝试使用同步操作的承诺？这仅仅是一种学习努力吗？因为没有实际的理由在纯同步操作中使用承诺——这只会使代码变得比需要的更复杂。不，这是一个非常实际的问题。函数A B C已经更改，现在我必须调整我的代码以使用它们。我仍然不明白。如果所有代码都是同步的，就没有理由使用承诺。只需像所有普通同步代码一样从函数返回一个值。如果我不清楚，很抱歉，但函数a、B和C超出了我的控制范围。在新版本中，它们变成了承诺。是的，这一点都不清楚。请