Question

因此，我是异步的新手，我无法理解它的工作原理，因为我可以理解它，但是当我执行它时，似乎没有。

所以，我有一个代码，我试图连续运行promise并携带变量，如果遇到错误，它将被捕获。

这是我正在尝试的简单代码：

var x = new Promise(function(resolve, reject) {
var one = 1
    resolve(one)
    // if error happens go to catch
})
.then(function(value) {
var two = 2;
    resolve(two);
    // if error happens go to catch
})
.then(function(value) {
var three = 3;
    resolve(three);
    // if error happens go to catch
})
.then(function(value) {
console.log(one + two + three);
})
.catch(function(value) {
    // reverse all the execution
})

x;

我正在创建一个承诺

第一个带有for循环的诺言包含要插入的对象

第二个承诺，它将在我的第一个表中插入一些行

第三个承诺将插入第一个表中的某些行，并从第二个承诺中插入一些结果

第四个承诺会完成一些事情，等等

和一个捕获，将删除由于错误而插入和剪切的数据。

这就是我想像的逻辑，代码和执行。

我正在使用mysql，顺便说一句。对于可以帮助我的人，我需要你。谢谢

如果您对我正在转换的真实代码感到好奇，这就是我到目前为止所做的：https://pastebin.com/Ui5vcUDg

我在这里使用了一些诺言，我在想，如果使用诺言链，我可以缩短或清理代码。

Answer 1

在这里，您可以通过创建一个累加器对象，然后将其向下传递，并在每个步骤中添加result属性，来沿承诺链向下传递值：

// Promises

var one = new Promise((resolve, reject) => {
  resolve(1)
})

var two = new Promise((resolve, reject) => {
  resolve(2)
})

var three = new Promise((resolve, reject) => {
  resolve(3)
})

// Promise Chain

one.then(one => {
  return ({ one })
})
.then(acc => {
  return two.then(two => ({ ...acc, two }))
})
.then(acc => {
  return three.then(three => ({ ...acc, three }))
})
.then(result => {
  console.log(result)
})
.catch(err => {
  console.error('one, two or three failed', err)
})

对于错误处理，如果Promise链中的任何返回的Promises拒绝，则链会中断并触发catch处理程序。

// Promises

var one = new Promise((resolve, reject) => {
  reject(new Error('Promise one error :('))
})

var two = new Promise((resolve, reject) => {
  resolve(2)
})

// Promise Chain

one.then(one => {
  return ({ one })
})
.then(acc => {
  return two.then(two => ({ ...acc, two }))
})
.then(result => {
  console.log(result)
})
.catch(err => {
  console.error(err)
})

您还可以通过在throw内then来触发错误：

var one = new Promise((resolve, reject) => {
  resolve(1)
})

var two = new Promise((resolve, reject) => {
  resolve(2)
})

one.then(one => {
  return ({ one })
})
.then(acc => {
  throw new Error('Error by explicit throw')
})
.then(acc => {
  return two.then(two => ({ ...acc, two }))
})
.then(result => {
  console.log(result)
})
.catch(err => {
  console.error(err)
})

注意：

two.then(two => ({ ...acc, two }))

大致等于：

two.then(two => {
  acc.two = two

  return acc
})

以防这种语法令人困惑。

Answer 2

在您放入“ then”的回调中，无需调用resolve（）即可调用链的下一步。您只需要返回一些值，链的下一步将接收它作为其参数。

您可能混淆了创建和链接承诺的方式。创建诺言时，将向其构造函数提供一个回调，其参数为“ resolve”和“ reject”，它们也是回调。它们应由promise构造函数内的回调内的代码调用。当您调用resolve时，promise将使用您提供的解决值来解决。拒绝也一样。

这个主题肯定令人困惑，我建议您仔细研究一下人们如何链接承诺以及人们如何创建自定义承诺。

将价值传承至承诺链

2 个答案: