Javascript 异步等待和承诺-如何改进语法

那么，我们如何创造句法上的糖分来隐藏一些复杂性呢

鉴于以下代码：

const Fridge = {
  async openDoor() {
    const myCake = new Promise(resolve => {setTimeout(()=> {
      console.log('door opened')
      resolve (Object.create(Cake))
    }, 2000)});
    await myCake
    return myCake
  }
}

const Cake= {
  eatCake(){ console.log ( 'yummy now I can eat my cake' ) }
}

const myFridge = Object.create(Fridge)

通常通过逐字访问：

myFridge.openDoor().then(myCake=>{
  myCake.eatCake()
  ... other code here .....
}) // complicated

可以创建一些糖来代替：

myFridge.openDoor().eatCake()  //simple to understand .then implied

或者更进一步，而不是：

myObject.myPromise.then(res=>{
   let x = res
   ... do stuff with x
});

相当于

let x = myObject.myPromise.res
... so stuff with x

---

从异步函数返回的任何内容都应用于后续调用。所有后续的代码都假定在。.then的闭包由封闭函数的结尾决定（类似于wait当前的工作方式）。

有一种语法称为

try（）catch（）

与

异步等待

例如：

async function someAsyncFunction () {
   try {
      const asyncValue = await asyncCall() //Promise
      console.log(asyncValue) // this will log only when asyncCall resolved
    }catch(error) {
     throw error
   }
  }

而不是使用

Promise

并链接一个

then（）

，并对其进行回调

您可以

等待asyncCall（）

并在该模式下继续使用解析值编写更多代码 而不是用回调链接更多函数

---

很难用一只脚来解释和理解，所以这里有一些

有一种语法叫做

try（）catch（）

与

异步等待

例如：

async function someAsyncFunction () {
   try {
      const asyncValue = await asyncCall() //Promise
      console.log(asyncValue) // this will log only when asyncCall resolved
    }catch(error) {
     throw error
   }
  }

而不是使用

Promise

并链接一个

then（）

，并对其进行回调

您可以

等待asyncCall（）

并在该模式下继续使用解析值编写更多代码 而不是用回调链接更多函数

---

很难用一只脚来解释和理解，因此这里有一些

您可以使用

wait

前面的

myFridge.openDoor（）

调用包装在括号中的表达式，然后chain

.eatCake（）

调用从

返回的对象的方法

您可以使用前面的
myFridge.openDoor（）
call wrapped in圆括号中来形成一个表达式，然后chain
.eatCake（）
来调用从
.openDoor（）返回的对象的方法

下面是一个解决方案，它提供了可用于隐藏等待和等待的复杂性的语法糖。然后：

const promiseNodeH = {
  get(target, prop) {
    if (prop in target || typeof prop !== 'string') return target[prop]
    return function() {
      const x = arguments
      const p3 = new Promise(resolve => {
        target.then(value => {
          resolve(value[prop](...x))
        })
      })
      return new Proxy(p3, Object.create(promiseNodeH))
    }
  }
}

const Cake = {
  eatCake(msg) {
    console.log(`starting to eat cake: ${msg}!`)
    const self = this
    return new Promise(resolve => {
      setTimeout(function() {
        console.log('cake eaten')
        resolve(self)
      }, 5000)
    })
  },
  getFat() {
    console.log('burp')
  }
}

const Fridge = {
  openDoor() {
    console.log('start to open door')
    const p1 = new Promise(resolve => {
      setTimeout(function() {
        console.log('door is open, here is your cake')
        resolve(Object.create(Cake))
      }, 5000)
    })
    return new Proxy(p1, Object.create(promiseNodeH))
  }
}

可通过以下方式访问：

Fridge.openDoor().eatCake('Yummy').getFat()

下面是一个解决方案，它提供了可用于隐藏等待和等待的复杂性的语法糖。然后：

const promiseNodeH = {
  get(target, prop) {
    if (prop in target || typeof prop !== 'string') return target[prop]
    return function() {
      const x = arguments
      const p3 = new Promise(resolve => {
        target.then(value => {
          resolve(value[prop](...x))
        })
      })
      return new Proxy(p3, Object.create(promiseNodeH))
    }
  }
}

const Cake = {
  eatCake(msg) {
    console.log(`starting to eat cake: ${msg}!`)
    const self = this
    return new Promise(resolve => {
      setTimeout(function() {
        console.log('cake eaten')
        resolve(self)
      }, 5000)
    })
  },
  getFat() {
    console.log('burp')
  }
}

const Fridge = {
  openDoor() {
    console.log('start to open door')
    const p1 = new Promise(resolve => {
      setTimeout(function() {
        console.log('door is open, here is your cake')
        resolve(Object.create(Cake))
      }, 5000)
    })
    return new Proxy(p1, Object.create(promiseNodeH))
  }
}

可通过以下方式访问：

Fridge.openDoor().eatCake('Yummy').getFat()

这如何适用于
myFridge.openDoor（）。然后
？这如何适用于
myFridge.openDoor（）。然后
？现在我想要一个蛋糕！非常感谢你！我在这里节食…：（现在我想要一个蛋糕！非常感谢！我在这里节食……：（谢谢你的回答，我已经想到了，但它仍然是一个半解，这将导致这些仍然难以阅读/创建的表达式：（wait（wait）（wait myFridge.openDoor（））.eatCake（））.getFat（）。但是比。尽管如此。@TrevTheDev不，代码不是一个“半解”。答案达到了问题中描述的要求。how is（wait（wait myFridge.openDoor（））.eatCake（））.getFat（）==myFridge.openDoor（）.eatCake（）.getFat（））？@TrevTheDev您在问题和上一条评论中假设的描述在实践中不可能使用JavaScript。答案中的代码使用表达式通过使用括号（表达式）实现基本相同或相似的模式对于每个
等待
链接方法所需的用法。谢谢@guest271314，你的原型设计想法让我陷入了一个兔子洞，这让我找到了代理，经过很多痛苦之后，解决方案发布了！感谢你的回复，我已经想到了，但这仍然是一个半解决方案，这将导致这些仍然难以阅读/创建按：（wait）（wait myFridge.openDoor（））.eatCake（））.getFat（）。但是比。好。@TrevTheDev不，代码不是“半解”。答案达到了问题中描述的要求。如何（wait（wait myFridge.openDoor（））.eatCake（））.getFat（）==myFridge.openDoor（）.eatCake（）.getFat（））？@TrevTheDev您在问题和上一条评论中假设的描述在实践中不可能使用JavaScript。答案中的代码使用表达式通过使用括号（表达式）实现基本相同或相似的模式对于链接一个方法所需的每个
wait
用法。谢谢@guest271314，你的原型设计想法让我陷入了一个兔子洞，这让我找到了代理，然后在经历了很多痛苦之后，发布了解决方案！”下面是一个避免wait和的解决方案。然后：“除了模式不避免
。然后（）
目标。然后（值=>{resolve（value[prop]（…x））}
@guest271314从接口的角度来看是这样做的：它允许向下游用户公开一个api，而不是乱七八糟的api。然后等待。用户只需键入Fridge.openDoor（）.eatCake（'Yummy'）.getFat（）-.then and await不是必需的。答案开头描述模式的文本不真实、不正确。代码实际上没有避免使用
.then（）如果你已经确信你的抽象符合问题的要求，那么就这样做。这并不意味着你可以让每个人相信你所认为的“复杂性”是隐藏的。“复杂性”是主观的。代码不被隐藏。答案的代码可以被认为具有更多的“复杂性”。而不是简单地使用
.then（）
和
等待
一个人打开抽象（读取源代码）.无论如何，这是你的问题，你已经回答了你自己的问题，显然你自己满意了，这才是重要的，因为这是你的问题。@guest271314哈哈，我希望让你相信我的论点的光辉——哦，我必须对我无误的自信感到满意；）。再次感谢您的挑战，它帮助您找到了此解决方案。”下面是一个避免等待和。然后：“除了模式不避免
。然后（）
目标。然后（value=>{resolve（value[prop]（…x））}）
@guest271314从