Node.js 未处理的PromisejectionWarning:TypeError:无法读取属性'；结果'；未定义的

我正在使用crating get api查找学生分数，并手动获取和比较分数

我有两个集合

学生

和

主题

都与参考id连接

这是我的app.js

 app.js

var express = require('express');
var mongoose = require('mongoose');
var app = express();
var school = require('./controllers/school_controller');
var port = 3000;
var http = require('http');


mongoose.connect(
    'mongodb://localhost:27017/company-info',
    {useNewUrlParser: true},
    err => {
        if(err) throw err;
        console.log('connection successfully');
    }
)

app.set('secreteKey', 'company-info');
app.use(cors({ maxAge: 600 }));
app.use(express.json());
app.use(express.urlencoded({extended: true}));

app.use('/school', school);


http.createServer(app).listen(port, function(req, res){
    console.log('start your server on: ', port);
}); 

这是我的模型：

models/school.js

const mongoose = require('mongoose');
const uniqueValidator = require('mongoose-unique-validator');
const bcrypt = require('bcrypt');
const saltRounds = 10;
const mongooseHidden = require('mongoose-hidden')()

var validateEmail = function(email) {
    var re = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
    return re.test(email)
};

var adminSchema = new mongoose.Schema({
    name: { type: String, required: "name is require"},
    mobile_no: { type: String,  minlength: 10, maxlength: 14, required: "mobile_no is require"},
    user_type: { type: String},
    email: { 
        type: String,
        required: 'email is require',
        lowercase: true,
        unique: true,
        validate: [validateEmail, 'Please fill a valid email address'] 
    },
    password: {
        type: String,
        required: true,
        hide: true
    }
});
adminSchema.pre('save',function(next){
    this.password = bcrypt.hashSync(this.password, saltRounds);
    next();
});
adminSchema.plugin(mongooseHidden);
adminSchema.plugin(uniqueValidator);
var admin = mongoose.model("admin", adminSchema);


var principleSchema = new mongoose.Schema({
    name: { type: String, required: "name is require"},
    mobile_no: { type: String, minlength: 10, maxlength: 14, required: "mobile_no is require"},
    degree: { type: String,  required: "degree is require"},
    user_type: { type: String,  required: true },
    email: { 
        type: String,
        required: true,
        lowercase: true,
        unique: true,
        validate: [validateEmail, 'Please fill a valid email address'] 
    },
    password: {
        type: String,
        required: true,
        hide: true
    }
});
principleSchema.pre('save',function(next){
    this.password = bcrypt.hashSync(this.password, saltRounds);
    next();
});
principleSchema.plugin(mongooseHidden);
principleSchema.plugin(uniqueValidator);
var principle = mongoose.model("principle", principleSchema);


var teacherSchema = new mongoose.Schema({
    // _id: mongoose.Schema.Types.ObjectId,
    name: { type: String, required: "name is require"},
    mobile_no: { type: String,  minlength: 10, maxlength: 14, required: "mobile_no is require"},
    class: { type: Number, required: "class is require" },
    user_type: { type: String },
    degree: { type: String, required: "degree is require" },
    email: { 
        type: String,
        required: 'email is require',
        lowercase: true,
        unique: true,
        validate: [validateEmail, 'Please fill a valid email address'] 
    },
    password: {
        type: String,
        required: true,
        hide: true
    }
});
teacherSchema.pre('save',function(next){
    this.password = bcrypt.hashSync(this.password, saltRounds);
    next();
});
teacherSchema.plugin(mongooseHidden);
teacherSchema.plugin(uniqueValidator);
var teacher = mongoose.model("teacher", teacherSchema);


var studentSchema = new mongoose.Schema({
    name: { type: String, required: "name is require"},
    roll_no: {type: Number, required: "roll_no is require"},
    class: { type: Number, require: "class is require"},
    user_type: { type: String },
    email: { 
        type: String,
        required: 'email is require',
        lowercase: true,
        unique: true,
        validate: [validateEmail, 'Please fill a valid email address'] 
    },
    password: {
        type: String,
        required: true,
        hide: true
    }
});
studentSchema.pre('save',function(next){
    this.password = bcrypt.hashSync(this.password, saltRounds);
    next();
});
studentSchema.plugin(mongooseHidden);
studentSchema.plugin(uniqueValidator);
var student = mongoose.model("student", studentSchema);


var subjectSchema = new mongoose.Schema({
    result: [{ subject: String, marks: Number }],
    student_id: { type: mongoose.Schema.Types.ObjectId, ref: 'student'}
});
subjectSchema.plugin(mongooseHidden, { hidden: { student_id: true}});
var subject = mongoose.model("subject", subjectSchema);


module.exports = { admin: admin, principle: principle, teacher: teacher, student: student, subject: subject }

这是我的控制器：

controllers/school_controller.js

var express = require('express');
var router = express.Router();
var school = require('../models/school');

router.get('/subject_pass',  function(req, res){
     school.student.find({ class: req.body.class}, async function(err, data){
            if(err){
                res.send(err);
            } else {
              //  res.send(data);
             // console.log(data);
              for(var i = 0; i <= 4; i++){
               // console.log(data[i]._id);
               await school.subject.find({ student_id: data[0]._id}, async function(err, info) {
                    if (err) {
                        res.send(err);
                    } else {
                            console.log(info);
                            for(var k = 0; k <= 2; k++){
                            console.log(info[i].result[k].subject)
                            console.log(info[i].result[k].marks)
                        }
                      await school.subject.aggregate([{ $match: { subject: req.body.subject }}], function(err, details){
                        if(err){
                            res.send(err);
                        } else {
                            console.log(details);
                        }
                    })
                    }
                });
            }       
        }
    })
})

 module.exports = router;

controller/school\u controller.js
var express=需要（“express”）；
var router=express.router（）；
var学校=需要（“../models/school”）；
路由器.get（'/subject_pass'，函数（req，res）{
school.student.find（{class:req.body.class}，异步函数（err，data）{
如果（错误）{
res.send（err）；
}否则{
//res.send（数据）；
//控制台日志（数据）；
对于（var i=0；i每当您使用
school.student.find（{class:req.body.class}，…）搜索主题时，
它将返回
info
变量中的
student
文档

根据映射，信息应包含>=0个条目，因此索引将从
0
开始，如：
info[0]
，
info[1]
等

但在代码中

for(var k = 0; k <= 2; k++){
  console.log(info[i].result[k].subject)
  console.log(info[i].result[k].marks)
}

或者如果存在多个
info

info.forEach((infoElement)=>{
    for(var k = 0; k <= 2; k++){
      console.log(infoElement.result[k].subject);
      console.log(infoElement.result[k].marks);
    }
});

info.forEach（（infoElement）=>{
对于（var k=0；k）在两个位置同时使用wait和callback有什么原因吗？
info.forEach((infoElement)=>{
    for(var k = 0; k <= 2; k++){
      console.log(infoElement.result[k].subject);
      console.log(infoElement.result[k].marks);
    }
});