Node.js Nodejs RANGERROR:超出最大调用堆栈大小，原因是响应中发送了对象

如果有人能帮我解决这个问题，那就太棒了

我目前遇到一个问题，调用此快速路由会在下面显示一个RangeError错误：超出了最大调用堆栈大小

似乎只有在我包含res.json（users[user]）时才会发生这种情况；功能。如果我将此函数替换为res.send（'Done'）；该函数运行良好

我尝试过setTimeout、setImmediate和process.nextTick，但都给出了相同的错误，差不多

我有点希望这对我来说是个愚蠢的错误

//Send Friend Request
router.post('/send/friend/request', auth, function(req, res, next){

 var query = User.find({$or: [
  {username: req.body.username},
  {username: req.payload.username}
 ]})
 .select(' username friends notifications');

 query.exec(function(err, users){
  if(err) return next(err);
  if(users.length < 2) console.log('/send/friend/request - There was an error      in accessing the users from the db');
  else{

   //Identify users in array
   var user = users.findIndex(function(element, index){
    if(element.username === req.payload.username)
      return element;
    });
   var requestUser = (user + 1) % 2;

   //addFriends
   users[user].friends.push({
     user: users[requestUser],
   });

   users[requestUser].friends.push({
     user: users[user],
     sent: false
   });

   //notifications
   users[user].notifications.push({ 
     user: users[requestUser],  
     type: 0, 
     summary: "Your friend request has been sent to " + req.body.username +".",
     status: "Pending..."
   });

   users[requestUser].notifications.push({
     user: users[user],  
     type: 1, 
     summary: "You have a new friend request from " + req.payload.username + ".",
     status: "Pending..."
   });

   users[requestUser].save(function(err){
     if(err) return next(err);
   });

   users[user].save(function(err){
    if(err) return next(err);
   });

     //Here lies the culprit
     res.json(users[user]);
  }
 });
});

//发送好友请求
router.post（'/send/friend/request'，auth，function（req，res，next）{
var query=User.find（{$or:[
{username:req.body.username}，
{username:req.payload.username}
]})
.选择（‘用户名朋友通知’）；
exec（函数（err，用户）{
if（err）返回next（err）；
if（users.length<2）console.log（“/send/friend/request-从数据库访问用户时出错”）；
否则{
//识别阵列中的用户
var user=users.findIndex（函数（元素，索引）{
if（element.username==req.payload.username）
返回元素；
});
var requestUser=（用户+1）%2；
//加朋友
用户[user].friends.push({
用户：用户[请求用户]，
});
用户[requestUser].friends.push({
用户：用户[用户]，
发送：错误
});
//通知
用户[user].notifications.push（{
用户：用户[请求用户]，
类型：0，
摘要：“您的好友请求已发送到“+req.body.username+”，
状态：“待定…”
});
用户[requestUser].notifications.push({
用户：用户[用户]，
类型：1，
摘要：“您有一个来自“+req.payload.username+”的新好友请求”，
状态：“待定…”
});
用户[requestUser]。保存（函数（错误）{
if（err）返回next（err）；
});
用户[user]。保存（函数（err）{
if（err）返回next（err）；
});
//罪魁祸首就在这里
res.json（用户[user]）；
}
});
});
也许

如果
user
本身包含引用，则
res.json
失败。因为
req.json
试图分解
unlimited
对象。要避免此问题，您可以：

指定要发送的用户字段

res.send（JSON.stringify（用户，['name'，'age'，…]））

将引用定义为不可枚举属性

Object.defineProperty（用户，'your ref'，{enumerable:false}）

也许

如果
user
本身包含引用，则
res.json
失败。因为
req.json
试图分解
unlimited
对象。要避免此问题，您可以：

指定要发送的用户字段

res.send（JSON.stringify（用户，['name'，'age'，…]））

将引用定义为不可枚举属性

Object.defineProperty（用户，'your ref'，{enumerable:false}）

显然，对象
users
不是JSON。它的POJO对象带有额外的mongo属性，这些属性包含对
\uuuuu proto\uuu
属性的递归引用

再次在客户端执行序列化和反序列化

或者在新对象文本中提取属性，然后传递给它
resp.json（）
明确地说，对象
用户
不是json。它的POJO对象带有额外的mongo属性，这些属性包含对
\uuuuu proto\uuuu
属性的递归引用

再次在客户端执行序列化和反序列化

或者在新对象文本中提取属性，然后传递给它
resp.json（）
您正在
用户[user]
和
用户[requestUser]
之间创建循环引用

下面的示例演示了问题：

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

const userSchema = Schema({ friends : [] });
const User       = mongoose.model('User', userSchema);

let user1 = new User();
let user2 = new User();

user1.friends.push(user2); 
user2.friends.push(user1); // the circular reference is created here

console.log( JSON.stringify(user1) );

由于该循环引用，
JSON.stringify（）
将抛出一个
RangeError

您可能需要重新考虑您的模式，因为我认为您无法将其用于您的目的。相反，您应该使用来存储文档之间的引用

当您将上面的架构更改为以下内容时，它不会抛出：

const userSchema = Schema({
  friends : [ { type : Schema.Types.ObjectId, ref : 'User' } ]
});

编辑：如果使用复杂对象作为数组内容，即使使用填充，也应推送
\u id
值，而不是文档：

users[user].friends.push({
  user: users[requestUser]._id,
});

您正在
用户[user]
和
用户[requestUser]
之间创建循环引用

下面的示例演示了问题：

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

const userSchema = Schema({ friends : [] });
const User       = mongoose.model('User', userSchema);

let user1 = new User();
let user2 = new User();

user1.friends.push(user2); 
user2.friends.push(user1); // the circular reference is created here

console.log( JSON.stringify(user1) );

由于该循环引用，
JSON.stringify（）
将抛出一个
RangeError

您可能需要重新考虑您的模式，因为我认为您无法将其用于您的目的。相反，您应该使用来存储文档之间的引用

当您将上面的架构更改为以下内容时，它不会抛出：

const userSchema = Schema({
  friends : [ { type : Schema.Types.ObjectId, ref : 'User' } ]
});

编辑：如果使用复杂对象作为数组内容，即使使用填充，也应推送
\u id
值，而不是文档：

users[user].friends.push({
  user: users[requestUser]._id,
});

这是我目前在我的用户模式朋友中的朋友：[{User:{type:mongoose.Schema.Types.ObjectId，ref:'User'}，friendRequest:{type:Boolean，默认值：true}，sent:{type:Boolean，默认值：true}，accepted:{type:Boolean，默认值：false}]，我不确定这是否是问题所在。@matrixentry137在这种情况下，您可能必须使用
.push（{user:users[requestUser].\u id}）
这是我当前在用户模式中作为朋友拥有的内容。朋友：[{user:{type:mongoose.Schema.Types.ObjectId，ref:'user'}，朋友请求：{type:Boolean，默认值：true}，已发送：{type:Boolean，默认值：true}，已接受：{type:Boolean，默认值：false}]，我不确定这是否是问题所在。@MatrixEntry1337在这种情况下，您可能必须使用
.push（{use