Javascript 承诺中的锁链承诺。所有没有包装的承诺

Promise.all是否可以在没有包装器承诺的情况下返回链的最后一个值

如果不使用wait，它在我的上下文中不起作用

没有包装器示例：

function sum1(x){
  return new Promise(resolve => {
    setTimeout(t => resolve(x+1),3000)
  })
}
const p1 = sum1(1);

p1
.then(sum1)
.then(sum1)

Promise.all([p1])
.then(v => console.log(v[0]));

它记录的是2，而不是预期的4

但如果我使用包装器，它会起作用：

function sum1(x){
  return new Promise(resolve => {
    setTimeout(t => resolve(x+1),3000)
  })
}

function sum3(x){
  return sum1(x)
  .then(sum1)
  .then(sum1)
}
const p2 = sum3(1);

Promise.all([p2])
.then(v => console.log(v[0]));

但在我的上下文中，如果我需要为每个承诺链创建并命名一个包装器函数，它就会变得复杂

---

这可能吗？

解释：代码的问题是存储在

const p1=sum1（1）中仅链的第一部分，在
Promise.all（[p1]）
中，您仅从第一部分获得结果（一种解决方案是将所有链存储在p1中，如下所示：
p1=sum1（1）。然后（sum1）。然后（sum1）
。但是在您的情况下，您根本不需要使用Promie.all（因为在您的示例中只有一个Promise p1/2）：


函数sum1（x）{
返回新承诺（解决=>{
setTimeout（t=>resolve（x+1），300）
})
}
//Promise.all（[sum1（1）.then（sum1）.then（sum1）]）.then（r=>console.log（r））；//这也行
sum1（1）.然后（sum1）.然后（sum1）.然后（r=>console.log（r））；
解释：您的代码的问题是，您只存储在
const p1=sum1（1）；
链的第一部分，而在
Promise中。所有（[p1]）
您只会从这第一部分得到结果（一个解决方案是将所有链存储在p1中，如下：
p1=sum1（1）。然后（sum1）。然后（sum1）
。但是在您的情况下，您根本不需要使用Promie.all（因为在您的示例中只有一个承诺p1/2）：


函数sum1（x）{
返回新承诺（解决=>{
setTimeout（t=>resolve（x+1），300）
})
}
//Promise.all（[sum1（1）.then（sum1）.then（sum1）]）.then（r=>console.log（r））；//这也行
sum1（1）.then（sum1）.then（sum1）.then（r=>console.log（r））；
实际上我所要做的就是调用变量声明中的链，所以它引用了上次调用的promise

function sum1(x){
  return new Promise(resolve => {
    setTimeout(t => resolve(x+1),3000)
  })
}

//The change is here
const p1 = sum1(1)
.then(sum1)
.then(sum1)

Promise.all([p1])
.then(v => console.log(v[0]));

实际上，我所要做的就是调用变量声明中的链，因此它引用最后一个调用的promise

function sum1(x){
  return new Promise(resolve => {
    setTimeout(t => resolve(x+1),3000)
  })
}

//The change is here
const p1 = sum1(1)
.then(sum1)
.then(sum1)

Promise.all([p1])
.then(v => console.log(v[0]));

您可以存储由
p1.然后（sum1）.然后（sum1）
返回的值，并对该值调用
Promise.all
。它不仅等待第一个承诺链的解析。以下是一个示例：

function sum1(x) {
  return new Promise(resolve => {
    setTimeout(t => resolve(x + 1), 10);
  });
}

const p1 = sum1(1);
const p2 = p1.then(sum1).then(sum1);

Promise.all([p1]).then(v => console.log('P1', v[0]));
Promise.all([p2]).then(v => console.log('P2', v[0]));

您可以存储由
p1.然后（sum1）.然后（sum1）
返回的值，并对该值调用
Promise.all
。它不仅等待第一个承诺链的解析。以下是一个示例：

function sum1(x) {
  return new Promise(resolve => {
    setTimeout(t => resolve(x + 1), 10);
  });
}

const p1 = sum1(1);
const p2 = p1.then(sum1).then(sum1);

Promise.all([p1]).then(v => console.log('P1', v[0]));
Promise.all([p2]).then(v => console.log('P2', v[0]));

创建一个新函数来完成您的任务怎么样，这看起来像是承诺。所有这些都不适合您的情况

const runInWaterfall = (promises) => new Promise((resolve, reject) => {
    const result = promises.reduce((acc, curr, index) => {
        if(!acc) {
            return curr();
        }
        return acc.then(curr);
    }, null);
    result.then(resolve).catch(reject);
})

您的任务可以重写如下

runInWaterfall([() => Promise.resolve(1), sum1, sum1, sum1]).then(result => console.log(result))

创建一个新函数来完成您的任务怎么样，这看起来像是承诺。所有这些都不适合您的情况

const runInWaterfall = (promises) => new Promise((resolve, reject) => {
    const result = promises.reduce((acc, curr, index) => {
        if(!acc) {
            return curr();
        }
        return acc.then(curr);
    }, null);
    result.then(resolve).catch(reject);
})

您的任务可以重写如下

runInWaterfall([() => Promise.resolve(1), sum1, sum1, sum1]).then(result => console.log(result))

忘了说没有await@Mojimi为什么不等待呢？在我的上下文中，我们被迫使用dojo小部件，它将所有东西都封装在一个我无法访问的函数中，所以等待不起作用。忘了提到否await@Mojimi为什么不等待呢？在我的上下文中，我们被迫使用dojo小部件，它将所有东西封装在一个我无法访问的函数中，所以等待不起作用从我的角度来看，kit看起来不如最初的链接承诺：DSure，但我认为他想将两者分离，这就是为什么。否则，我同意最初的承诺，这更清楚。从我的角度来看，它看起来不如最初的链接承诺：DSure，但我认为他想分离在两者之间，这就是为什么。否则我同意最初的承诺，它更清楚。