Question

我是Mongoose的新手，也使用异步/等待。现在，我有一个Mongoose模式，带有静态方法，如下所示：

const userSchema = new Schema({
    username: String,
    pass: String
});


userSchema.statics.checkExist = async function(username){
    return await this.findOne({username: username}, function(err, res){
        if(err){
            return err;
        }
        if(res){
            return true;
        }
        else{
            return false;
        }
    })
}

应该使用静态方法checkExist()来获取用户名，并检查是否存在使用相同用户名的文档。如果是这样，它将返回true，否则返回false。我像这样在NodeJS / Express服务器中使用它：

router.post('/auth/login', async (req, res) =>{
    let username = req.body.username;

    let existBool = await UserModel.checkExist(username);

    console.log(existBool);
    res.send({'hash': existBool});
});

我希望existBool是正确/错误的布尔值。相反，checkExist()似乎根本没有调用回调函数。而是返回findOne()的结果，该结果是具有匹配的用户名字段的对象。我在这里做什么错了？

Answer 1

您正在将回调与使用承诺的async/await混合使用。您还会误解回调的工作方式。 await的结果不是回调的返回值，而是findOne()的返回值。

await用于保持，直到异步函数返回promise，然后将其“解包”为变量。如果findOne()方法支持promise，则根本不应该使用回调。

let result = await this.findOne({username: username})

async/await如此强大的原因是，它消除了对.then() Promise语法的需要，并允许您再次编写顺序代码，但是让它处理异步行为。它允许您使用循环，最重要的是，您可以使用try/catch语句再次处理错误。

try {
  let result = await this.findOne({username: username})
} catch(ex) {
  // handle exception here
}

Answer 2

这是架构

const mongoose = require('mongoose');

var userSchema = new mongoose.Schema({
    _id: mongoose.Schema.Types.ObjectId,
    username: {
        type: String,
        required: true,
        unique: true
    },
    password: {
        type: String,
        required: true
    }
}, {
        timestamps: { createdAt: true, updatedAt: true },
        collection: 'users'
    });

module.exports = mongoose.model("User", userSchema);

路由器终点在下面

// API endpoint to insert new user.
router.post('/insertUser', function (req, res, next) {
    let request = req.body;
    let userSchema = new UserModel({
        _id: new mongoose.Types.ObjectId(),
        username: request.username,
        password: request.password
    }); `enter code here`

    if (!userSchema.username) {
        res.status(200).json({ success: false, msg: 'Username can\'t be empty' });
    } else if (!userSchema.password) {
        res.status(200).json({ success: false, msg: 'Password can\'t be empty' });
    } else {
        // If username is not unique in schema do check this...
        UserModel.findOne({ username: userSchema.username }).exec()
            .then(result => {
                if (result == null) {
                    //Here the User is added
                    userSchema.save().then(result => {
                        res.status(200).json({ success: true, msg: 'User Added' });
                    }).catch(exception => {
                        console.log(exception);
                        res.status(200).json({ success: false, msg: 'Something went wrong' });
                    });
                } else {
                    res.status(200).json({ success: false, msg: 'Username already taken' });
                }
            }).catch(exception => {
                console.log(exception);
                res.status(200).json({ success: false, msg: 'Something went wrong' });
            });
    }

});

猫鼬的find（）回调实际上并未被调用

2 个答案: