Node.js nodejs/mongoose：我的chained.then（）调用有什么问题

我下面的代码正在尝试：

创建

用户

模型的实例

在

订户

模型中查找与新创建的用户具有相同电子邮件地址的实例

将新用户的

subscribedAccount

属性与

Subscriber

实例相关联，该实例由

findOne

查询

用户的电子邮件找到

代码：

控制台结果：

在运行的服务器已成功连接到 猫鼬

使用电子邮件检查订户的结果test@test.com：
{组： []，_id:5aa422736518f30fbc0f77e2，名称：“测试名称”，电子邮件： 'test@test.com，zipCode:11111，_v:0}

已创建用户的电子邮件地址：test@test.com

findOne找到并传递给此的任何内容。然后（）？：未定义

为什么

Subscriber.findOne

返回

未定义的
？这是真的发生了什么，还是我错过了什么

以下是我对
用户
和
订户
的模型定义。如果您需要查看应用程序中的任何其他内容来告诉我发生了什么

用户
：

const mongoose = require('mongoose');
const {Schema} = require('mongoose');

var userSchema = new Schema( {
  name: {
    first: {
      type: String,
      trim: true
    },
    last: {
      type: String,
      trim: true
    }
  },
  email: {
    type: String,
    required: true,
    lowercase: true,
    unique: true
  },
  zipCode: {
    type: Number,
    min: [ 10000, 'Zip code too short' ],
    max: 99999
  },
  password: {
    type: String,
    required: true
  },
  courses: [ {
    type: Schema.Types.ObjectId,
    ref: 'Course'
  } ],
  subscribedAccount: {
    type: Schema.Types.ObjectId,
    ref: 'Subscriber'
  }
}, {
  timestamps: true
} );

userSchema.virtual('fullName').get(function() {
  return `${this.name.first} ${this.name.last}`;

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

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

let subscriberSchema = new Schema({
  name: {
    type: String,
    required: true
  },
  email: {
    type: String,
    required: true,
    lowercase: true,
    unique: true
  },
  zipCode: {
    type: Number,
    min: [10000, 'Zip Code too short'],
    max: 99999
  },
  groups: [{type: Schema.Types.ObjectId, ref: 'Group'}]
});

subscriberSchema.methods.getInfo = function() {
  return `Name: ${this.name} Email: ${this.email} Zip Code: ${this.zipCode}`;
}
subscriberSchema.methods.findLocalSubscribers = function() {
  return this.model('Subscriber')
             .find({zipCode: this.zipCode})
             .exec();
}

//model.exports = mongoose.model('Subcriber', subscriberSchema);

var Subscriber = exports.Subscriber = mongoose.model('Subscriber', subscriberSchema);

订户
：

const mongoose = require('mongoose');
const {Schema} = require('mongoose');

var userSchema = new Schema( {
  name: {
    first: {
      type: String,
      trim: true
    },
    last: {
      type: String,
      trim: true
    }
  },
  email: {
    type: String,
    required: true,
    lowercase: true,
    unique: true
  },
  zipCode: {
    type: Number,
    min: [ 10000, 'Zip code too short' ],
    max: 99999
  },
  password: {
    type: String,
    required: true
  },
  courses: [ {
    type: Schema.Types.ObjectId,
    ref: 'Course'
  } ],
  subscribedAccount: {
    type: Schema.Types.ObjectId,
    ref: 'Subscriber'
  }
}, {
  timestamps: true
} );

userSchema.virtual('fullName').get(function() {
  return `${this.name.first} ${this.name.last}`;

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

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

let subscriberSchema = new Schema({
  name: {
    type: String,
    required: true
  },
  email: {
    type: String,
    required: true,
    lowercase: true,
    unique: true
  },
  zipCode: {
    type: Number,
    min: [10000, 'Zip Code too short'],
    max: 99999
  },
  groups: [{type: Schema.Types.ObjectId, ref: 'Group'}]
});

subscriberSchema.methods.getInfo = function() {
  return `Name: ${this.name} Email: ${this.email} Zip Code: ${this.zipCode}`;
}
subscriberSchema.methods.findLocalSubscribers = function() {
  return this.model('Subscriber')
             .find({zipCode: this.zipCode})
             .exec();
}

//model.exports = mongoose.model('Subcriber', subscriberSchema);

var Subscriber = exports.Subscriber = mongoose.model('Subscriber', subscriberSchema);

你应该这样做

// Check that I have a subscriber with email 'test@test.com'
    Subscriber.findOne({email:'test@test.com'})
              .then(d => console.log(`\nResult of check for a subscriber with email test@test.com:\n ${d}`));

    User.create({name: {first: 'test first', last: 'test last'}, email: 'test@test.com', password: 'pass123'})
    .then(u => {
      user = u;
      // Check that user.email contains 'test@test.com'
      console.log(`\nCreated user's email address: ${user.email}\n`);
      Subscriber.findOne({email: user.email});


      console.log(`\nAnything found by findOne and passed to this .then()?: ${s}`);
      user.subscribedAccount = s;
      user.save()
      .then(s => {
            //user has been updated
        })
      .catch(err => {
         res.status(err).json(err);
         })

      })
       })
     . catch(e => console.log(e.message));

你需要归还它。在第一个表达式中，然后返回最后一个表达式。