避免在 javascript 中循环多次返回 - async / await 以解决回调金字塔或回调地狱，

Question

我有这段代码，有很多返回块，例如 SignUp()

connectors.js

  const connectors = {
      Auth: {
        signUp(args) {
          return new Promise((resolve, reject) => {
            // Validate the data
            if (!args.email) {
              return reject({
                code: 'email.empty',
                message: 'Email is empty.'
              });
            } else if (!isEmail(args.email)) {
              return reject({
                code: 'email.invalid',
                message: 'You have to provide a valid email.'
              });
            }

            if (!args.password) {
              return reject({
                code: 'password.empty',
                message: 'You have to provide a password.'
              });
            }

            return encryptPassword(args.password, (err, hash) => {
              if (err) {
                return reject(new Error('The password could not be hashed.'));
              }

              return User.create(Object.assign(args, { password: hash }))
                .then((user) => {
                  resolve(createToken({ id: user._id, email: user.email }));
                })
                .catch((err2) => {
                  if (err2.code === 11000) {
                    return reject({
                      code: 'user.exists',
                      message: 'There is already a user with this email.'
                    });
                  }

                  return reject(err2);
                });
            });
          });
        },
    };

    module.exports = connectors;

然后调用此代码的另一个代码：

 const connectors = require('./connectors');

   CallsignUp(root, args) {
      const errors = [];

      return connectors.Auth.signUp(args)
        .then(token => ({
          token,
          errors
        }))
        .catch((err) => {
          if (err.code && err.message) {
            errors.push({
              key: err.code,
              value: err.message
            });
            return { token: null, errors };
          }

          throw new Error(err);
        });
    } 

在 ES6 或 ES7 或 ES2017 中如何避免这种情况？

有：

  return()
   .then()
     return()
       .then

然后循环返回：

return()
   return()
       return()

来自 PHP 的这段代码看起来很疯狂，因为 return 函数返回函数，我不清楚，javascript 中的这种类型的块返回代码的名称是什么？调用再次返回更多代码的函数？

更新：

代码不是我的，完整源代码在

https://github.com/jferrettiboke/react-auth-app-example

我想通过例子来理解：

    return encryptPassword(args.password, (err, hash) => {
      if (err) {
        return reject(new Error('The password could not be hashed.'));
      }

      return User.create(Object.assign(args, { password: hash }))
        .then((user) => {
        .catch((err2) => {

          return reject(err2);

/src/utils/auth.js（这里是加密密码）

const jwt = require('jsonwebtoken');
const bcrypt = require('bcrypt-nodejs');
const config = require('../config');
exports.encryptPassword = (password, callback) => {
  // Generate a salt then run callback
  bcrypt.genSalt(10, (err, salt) => {
    if (err) { return callback(err); }

    // Hash (encrypt) our password using the salt
    return bcrypt.hash(password, salt, null, (err2, hash) => {
      if (err2) { return callback(err2); }
      return callback(null, hash);
    });
  });
};

有3个返回调用函数和返回值和函数？ OOP 从来都不是这样，@dashmud 建议的如何使用 Async/Await，我不想学习回调之类的老东西

Answer 1

此代码需要以多种方式重构。首先，你真的，真的不想在同一个逻辑流程中混合使用 Promise 和普通的异步回调。它弄得一团糟，破坏了 promise 的许多优点。然后，你有一个使用 new Promise() 内部的 Promise 的反模式。然后，您需要更多的嵌套（您可以改为链式）。

以下是我的建议：

function encryptPasswordPromise(pwd) {
    return new Promise((resolve, reject) => {
        encryptPassword(pwd, (err, hash) => {
            err ? reject(new Error("The password could not be hashed.")) : resolve(hash);
        });
    });
}

const connectors = {
    Auth: {
        signUp(args) {
            // Validate the data
            let err;
            if (!args.email) {
                err = {code: 'email.empty', message: 'Email is empty.'};
            } else if (!isEmail(args.email)) {
                err = {code: 'email.invalid', message: 'You have to provide a valid email.'};
            } else if (!args.password) {
                err = {code: 'password.empty', message: 'You have to provide a password.'};
            }
            if (err) {
                return Promise.reject(err);
            } else {
                return encryptPasswordPromise(args.password).then(hash => {
                    args.password = hash;
                    return User.create(args);
                }).then((user) => {
                    return createToken({id: user._id, email: user.email});
                }).catch(err2 => {
                    if (err2.code === 11000) {
                        throw new Error({code: 'user.exists', message: 'There is already a user with this email.'});
                    } else {
                        throw err2;
                    }
                });
            }
        }
    }
};

变更摘要：

1. 最初收集所有错误，并在一个地方为所有这些初始错误返回Promise.reject(err)。
2. Promisify encryptPassword() 这样您就不会将常规回调与 Promise 逻辑流混为一谈，这样您就可以正确地返回和传播错误。
3. 使用return new Promise() 删除整个代码的包装，因为您的所有异步操作现在都已承诺，因此您可以直接返回承诺。这也确实有助于正确处理错误。
4. 撤消不必要的嵌套并改为链式。
5. 删除 Object.assign()，因为似乎没有原因。

---

在您的编辑中，您要求对此代码段进行解释：

return encryptPassword(args.password, (err, hash) => {
  if (err) {
    return reject(new Error('The password could not be hashed.'));
  }

  return User.create(Object.assign(args, { password: hash }))
    .then((user) => {
    .catch((err2) => {

      return reject(err2);

1. 此代码调用encryptPassword()。
2. 它返回可能是undefined 的结果，所以return 所做的只是控制程序流（退出包含函数），但由于在同一级别返回之后没有代码，所以这是不必要的.
3. 您将回调传递给encryptPassword()。该回调是异步的，这意味着它会在一段时间后调用。
4. 回调有两个参数：err 和hash。在 node.js 异步调用约定中，如果第一个参数是真实的（例如，包含一些真实的值），那么它代表一个错误。如果是假的（通常是null），那么没有错误，第二个参数包含异步操作的结果。
5. 如果出现错误，则拒绝父 Promise 并退出回调。同样，reject 没有返回值，所以 return 只是用于退出回调（因此回调中没有其他代码运行）。
6. 然后，另一个异步操作User.create() 被调用，并传递给其中设置了新密码的args 对象。
7. User.create() 返回一个 Promise，因此它的结果被 .then() 方法捕获并传递给它的回调。
8. 一段时间后，当异步User.create() 完成时，它将解析其承诺，这将导致.then() 回调被调用并将结果传递给它。如果该操作出错，则不会调用.then() 回调，而是调用.catch() 回调。在那个.catch() 回调中，父承诺被拒绝。这是一个 Promise 反模式（在另一个 Promise 中解析父 Promise），因为在正确的错误处理中很容易出错。我的回答显示了如何避免这种情况。

Answer 2

扩展@jfriend00's answer，这是一种使用ES2017 async / await 语法来展平callback pyramid 或callback hell 的方法，但是您更喜欢这样称呼它：

const encryptPasswordPromise = require('util').promisify(encryptPassword)

const connectors = {
  Auth: {
    async signUp (args) {
      const { email, password } = args
      // Validate the data
      let err

      if (!email) {
        err = { code: 'email.empty', message: 'Email is empty.' }
      } else if (!isEmail(email)) {
        err = { code: 'email.invalid', message: 'You have to provide a valid email.' }
      } else if (!password) {
        err = { code: 'password.empty', message: 'You have to provide a password.' }
      }

      if (err) {
        throw err
      }

      let hash

      try {
        hash = await encryptPasswordPromise(password)
      } catch (err) {
        throw new Error('The password could not be hashed.')
      }

      const { _id: id, email } = await User.create(Object.assign(args, { password: hash }))

      try {
        return createToken({ id, email })
      } catch (err) {
        if (err.code === 11000) {
          throw { code: 'user.exists', message: 'There is already a user with this email.' }
        } else {
          throw err
        }
      }
    }
  }
}

module.exports = connectors

我选择使用 node.js 内置转换函数，而不是手写我自己的基于承诺的 encryptPassword()。

总体而言，仍然可以进行一些改进，例如将 signUp() 参数的验证移至单独的函数，但这些都与扁平化“回调地狱”反模式有关基于 promise 的控制流和 async/await 语法。

Answer 3

首先要做的事情。您的代码中没有循环。

如果您来自 PHP，那么我猜 Javascript 的异步执行模型对您来说似乎很陌生。我建议学习更多关于 Javascript 的知识。

按以下顺序学习以下内容：

1. 回调
2. 承诺
3. 发电机
4. 异步/等待

这些是处理 Javascript 异步执行模型的不同方法，从最基本的（回调）到最现代的方法“async/await”。

Async/await 将是最易读的，但如果您了解 async/await 是如何产生的会更好，因为如果您不了解自己在做什么，它们很容易以错误的方式使用。