javascript - 函数返回一个 promise 而不是它应该返回的对象

Question

当我遇到一个我不太理解的相当奇怪的错误时，我正在编写一个 MEAN 堆栈应用程序。

我编写的其中一个函数应该返回一个常规 JSON 对象，其中包含将在函数执行时设置的某些参数。然而，事实并非如此。它会返回一个 promise 对象。

我创建了一个用户模型，然后为它创建了一些方法/函数。返回 promise 的相关函数是 validate 函数。

这个函数的作用很简单，就是确保用户输入的数据是经过检查的!从 user.js 中的代码可以看出，它只是检查输入数据的长度，并将其与一些预定义的正则表达式进行匹配，以查看数据是否在可接受的范围内(为了不以后会引起问题)。

我在用户注册时调用此函数，这发生在 registerController.js 中的注册函数中，它还应该查找用户是否已经存在(之前创建过帐户)或者他选择的用户名被占用(用户名存在)之后，它会向他们发送一封确认电子邮件，其中包含一个链接，该链接是他们的临时 token 。引导用户注册的路由在registerRoutes.js中。我尝试记录从函数 checkData 和 validate 接收到的对象的值。 checkData 返回一个普通对象，而 validate 返回一个 promise ，即使它不应该。

这里是用户文件user.js

const mongoose = require('mongoose');

var userSchema = new mongoose.Schema({
    username: {
        type: String,
        required: true,
        unique: true
    },
    email:{
        type: String,
        required: true,
        unique: true
    },
    password:{
        type: String,
        required: true
    },
    firstName:{
        type: String,
        required: true
    },
    lastName:{
        type: String,
        required: true
    },
    confirmed:{
        type: Boolean,
        default:false,
        required: true
    },
    temporaryToken:{
        type: String,
        default: "NO_TOKEN",
        required: true
    }
});

userSchema.method({
    checkData: function() {
        let checkData = {};
        checkData.missing = [];
        checkData.wrongType = [];
        checkData.success = true;
        if(!this.username)
        {
            checkData.success = false;
            checkData.missing.push("username");
        }
        if(!this.email)
        {
            checkData.success = false;
            checkData.missing.push("email");
        }
        if(!this.password)
        {
            checkData.success = false;
            checkData.missing.push("password");
        }
        if(!this.firstName)
        {
            checkData.success = false;
            checkData.missing.push("firstName");
        }
        if(!this.lastName)
        {
            checkData.success = false;
            checkData.missing.push("lastName");
        }
        return checkData;
    },
    validate: function() {
        let validation = {};
        validation.errors = [];
        validation.success = true;
        if(this.username.length < 2 || this.username.length > 35)
        {
            validation.success = false;
            validation.errors.push({
                "field": "username",
                "message": "Invalid length of username. Username must be between 2 and 35 characters long."
            });
        }
        if(this.email.length < 6 || this.username.length > 256)
        {
            validation.success = false;
            validation.errors.push({
                "field": "email",
                "message": "Invalid length of email. Email must be between 6 and 256 characters long."
            });
        }
        if(this.password.length < 8 || this.password.length > 50)
        {
            validation.success = false;
            validation.errors.push({
                "field": "password",
                "message": "Invalid length of password. Password must be between 6 and 256 characters long."
            });
        }
        if(this.firstName.length < 2 || this.firstName.length > 35)
        {
            validation.success = false;
            validation.errors.push({
                "field": "firstName",
                "message": "Invalid length of first name. First name must be between 2 and 35 characters long."
            });
        }
        if(this.lastName.length < 2 || this.lastName.length > 35)
        {
            validation.success = false;
            validation.errors.push({
                "field": "lastName",
                "message": "Invalid length of last name. Last name must be between 2 and 35 characters long."
            });
        }
        let usernameRegex = /^[a-zA-Z0-9$#@%`'"\.]+$/
        if(!usernameRegex.test(this.username))
        {
            validation.success = false;
            validation.errors.push({
                "field": "username",
                "message": "Invalid format of username. Username can only contain Alphanumeric characters and $ # @ % ` ' \" and .."
            });
        }
        let emailRegex = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
        if(!emailRegex.test(this.email))
        {
            validation.success = false;
            validation.errors.push({
                "field": "email",
                "message": "Invalid format and email. Email has to be in the form example@domain.com."
            })
        }
        let passwordRegex = /^[A-Za-z0-9$#@%`'"\.]+$/;
        if(!passwordRegex.test(this.password))
        {
            validation.success = false;
            validation.errors.push({
                "field": "email",
                "message": "Invalid format of password. Password an only contain Alphanumeric characters and $ # @ % ` ' \" and .."
            });
        }
        let nameRegex = /^[A-Z][a-z-]+$/;
        if(!nameRegex.test(this.firstName))
        {
            validation.success = false;
            validation.errors.push({
                "field": "firstName",
                "message": "Invalid format of first name. First Name can only contain English letters and hyphens (-)."
            });
        }
        if(!nameRegex.test(this.middleName))
        {
            validation.success = false;
            validation.errors.push({
                "field": "middleName",
                "message": "Invalid format of middle name. Middle Name can only contain English letters and hyphens (-)."
            });
        }
        if(!nameRegex.test(this.lastName))
        {
            validation.success = false;
            validation.errors.push({
                "field": "lastName",
                "message": "Invalid format of last name. Last Name can only contain English letters and hyphens (-)."
            });
        }
        return validation;
    },
    capitalizeNames: function() {
        this.firstName = this.firstName.charAt(0).toUpperCase() + this.firstName.slice(1);
        this.lastName = this.lastName.charAt(0).toUpperCase() + this.lastName.slice(1);
    }
});

const UserModel = mongoose.model("user", userSchema);

module.exports = UserModel;

这里是注册 Controller 文件registerController.js

const User = require("../model/user.js");
const system = require("../middleware/system.js");
const mails = require("../../config/mails.js");
const bcrypt = require("bcrypt");
const jwt = require("jsonwebtoken");
const nodemailer = require('nodemailer');

let registerController = {
    register: function(req, res, next) {
        let newUser = new User ({
            "username": req.body.username,
            "email": req.body.email,
            "password": req.body.password,
            "firstName": req.body.firstName,
            "lastName": req.body.lastName,
        });
        let check = newUser.checkData();
        if(!check.success)
        {
            res.status(400).json(check);
            next();
            return;
        }
        newUser.capitalizeNames();
        let validity = newUser.validate();
        console.log(validity); // "Promise { <pending> }"
        if(!validity.success)
        {
            res.status(400).json(validity);
            next();
            return;
        }
        newUser.findOne({"username": newUser.username}, function(err, foundUser1) {
            if(err)
            {
                system.handleServerError(res);
                next();
                return;
            }
            if(foundUser1)
            {
                res.status(403).json({
                    "success": false,
                    "message": "The user with the name " + newUser.username + " already exists. Please choose another name."
                });
                next();
                return;
            }
            newUser.findOne({"email": newUser.email}, function(err, foundUser2) {
                if(err)
                {
                    system.handleServerError(res);
                    next();
                    return;
                }
                if(foundUser2)
                {
                    res.status(403).json({
                        "success": false,
                        "message": "The user with the email " + newUser.email + " already exists. If you already have an account, please log in."
                    });
                    next();
                    return;
                }
                bcrypt.hash(newUser.password, saltRounds, function(err, hash) {
                    newUser.password = hash;
                    newUser.temporaryToken = jwt.sign({
                        "email": newUser.email
                    }, "confirm", {
                        expiresIn: 60*60*24*365
                    });
                    newUser.save(function(err, product, numAffected) {
                        if(err)
                        {
                            system.handleServerError(res);
                            next();
                            return;
                        }
                        // SEND EMAIL TO USER
                        res.status(200).json({
                            "success": true,
                            "message": "Your registration has been completed successfully. A confirmation link has been sent to your email. Please use that link to actvate your account and login."
                        });
                        next();
                        return;
                    });
                });
            });
        });
    }
};

module.exports = registerController;

这是路由文件 registerRoutes.js

const express = require("express");
const router = express.Router();
const registerController = require("../controllers/registerController.js")

router.post("/api/register", registerController.register);

module.exports = router;

如果有任何其他信息我可以提供或澄清，请告诉我。谢谢大家的宝贵时间。 :)

Answer 1

错误在于函数的命名。

validate() 已在 mongoose 模块中定义。在调用 native Mongoose 函数的用户模型实例上调用它，该函数需要回调，因此返回了一个 promise 。

幸运的是，将 validate() 更改为 validator() 解决了问题。