我得到这个错误。错误[ERR_HTTP_HEADERS_SENT]。不能在头文件被发送至客户端后设置它们。

Question

当我发送POST请求登录时，就会显示这个Error，我已经使用了mongoose & MongoDB Atlas。我使用了mongoose & MongoDB Atlas。

如果我用有效的电子邮件& 密码发送POST请求，它也显示这个错误。

错误[ERR_HTTP_HEADERS_SENT]。无法在头文件发送到客户端后设置它们。

但POST请求注册的效果很好。

用户模型

const mongoose = require('mongoose')
const Schema = mongoose.Schema

const userSchema = new Schema({
    name: {
        type: String,
        required: true,
        trim: true
    },
    email: {
        type: String,
        required: true,
    },
    password: {
        type: String,
        required: true
    }, 
    balance: Number,
    income: Number,
    expense: Number,
    transactions: {
        type: [{
            type: Schema.Types.ObjectId,
            ref: 'Transaction'
        }]
    }
})

const User = mongoose.model('User', userSchema)
module.exports = User

用户控制器

const registorValidate = require('../validator/registrationValidate')
const User = require('../models/userModel')
const bcrypt = require('bcrypt')
const loginValidate = require('../validator/loginValidator')
const jwt = require('jsonwebtoken')

module.exports = {
    login: (req, res) => {
        const { email, password } = req.body
        let logValidate = loginValidate({ email, password })

        if (!logValidate.isValid) {
            res.status(400).json(logValidate.error)
            return
        }

        User.findOne({ email })
            .then(user => {
                if (!user) {
                    console.log(`${email} not found`)
                    res.json({
                        msg: `${email} not found`
                    })
                }
                bcrypt.compare(password, user.password, (err, result) => {
                    if (err) {
                        res.status(400).json({
                            msg: 'Error occured'
                        })
                    }
                    if (!result) {
                        res.status(404).json({
                            msg: `Password doesn't match`
                        })
                    }
                    let token = jwt.sign({
                        _id: user._id,
                        name: user.name,
                        email: user.email
                    }, 'SECRET', { expiresIn: '2h' })

                    res.status(200).json({
                        msg: 'Login successful',
                        token: `Bearer ${token}`
                    })

                })
                return
            })
            .catch(err => {
                res.status(500).json({
                    msg: 'Error occured'
                })
            })

        res.end()

    },
    registration: (req, res) => {
        let { name, email, password, confirmPassword } = req.body
        let validate = registorValidate({ name, email, password, confirmPassword })

        if (!validate.isValid) {
            res.status(400).json(validate.error)
        } else {
            User.findOne({ email })
                .then(user => {
                    if (user) {
                        res.json({
                            msg: `${email} is already exist`
                        })
                    } else {
                        bcrypt.hash(password, 11, (err, hash) => {
                            if (err) {
                                res.status(500).json({
                                    msg: 'Server error occured'
                                })
                            }
                            let user = new User({
                                name,
                                email,
                                password: hash
                            })
                            user.save()
                                .then(user => {
                                    res.status(201).json({
                                        msg: `Thanks ${name} for your registration`,
                                        user
                                    })
                                })
                                .catch(err => {
                                    res.status(500).json({
                                        msg: 'Error occured'
                                    })
                                })
                        })
                    }
                })
                .catch(err => {
                    res.status(500).json({
                        msg: 'Error occured'
                    })
                })
        }
    }
}

登录验证器

const validator = require('validator')

const validate = user => {
    let error = {}

    // Email validator
    if (!user.email) {
        error.email = 'Please provide an Email'
    } else if (!validator.isEmail(user.email)) {
        error.email = 'Please provide a valid Email'
    }

    // Password validate
    if (!user.password) {
        error.password = 'Please provide a password'
    } else if (user.password.length < 6) {
        error.password = 'Password Must be greater or Equal to 6 characters'
    }

    return {
        error,
        isValid: Object.keys(error).length === 0
    }
}

module.exports = validate

谢谢。

Answer 1

你不需要把 res.end() 因为当你打电话 res.json() 之前，它已经发送了回复。

请注意，您应该 return 当你打电话 res.end(), res.send()、'res.json()'和其他发送响应的操作，就像你用 res.status(400).json(logValidate.error)

这应该是防止你得到的方法之一。ERR_HTTP_HEADERS_SENT但要注意的是，如果你有嵌套回调，你应该在 return 也从外部范围