Javascript 跳过分析afterSave函数

因此，我有一个使用parse.com作为后端的消息传递应用程序。当我从应用程序发送消息时，它会将消息保存在Parse.com上的一个名为“NewMessages”的类中。然后在我的云代码中，我有一个专门用于这个类的afterSave函数，这样当一个新对象被保存到“NewMessages”中时，它会随机选择一个用户将其附加到消息中，并将其保存到一个名为“Inbox”的新类中。然后从“NewMessages”中删除原始消息

所以“NewMessages”类应该总是空的，对吗？但是当我很快发送一堆信息时，有些信息会被跳过。我该如何解决这个问题

有没有比使用afterSave更好的方法来构建此结构

function varReset(leanBody, leanSenderName, leanSenderId, randUsers){
   leanBody = "";
   leanSenderName = "";
   leanSenderId = "";
   randUsers = [];
   console.log("The variables were set");
}


Parse.Cloud.afterSave("Lean", function(leanBody, leanSenderName, leanSenderId, randUsers, request) {
  varReset(leanBody, leanSenderName, leanSenderId, randUsers);

  var query = new Parse.Query("NewMessages");
  query.first({
    success: function(results){
      leanBody = (results.get("MessageBody"));
      leanSenderName = (results.get("senderName"));
      leanSenderId = (results.get("senderId"));
      getUsers(leanBody, leanSenderName, leanSenderId);
      results.destroy({
        success: function(results){
          console.log("deleted");
        }, error: function(results, error){
        }
      });
    }, error: function(error){
    }

  });
});

  function getUsers(leanBody, leanSenderName, leanSenderId, response){

    var query = new Parse.Query(Parse.User);
    query.find({
        success: function(results){
            var users = [];
            console.log(leanBody);
            console.log(leanSenderName);

            //extract out user names from results
            for(var i = 0; i < results.length; ++i){
                users.push(results[i].id);
            }
            for(var i = 0; i < 3; ++i){
                var rand = users[Math.floor(Math.random() * users.length)];
                var index = users.indexOf(rand);
                users.splice(index, 1);
                randUsers.push(rand);
                }
            console.log("The random users are " + randUsers);
            sendMessage(leanBody, leanSenderName, leanSenderId, randUsers);
        }, error: function(error){
            response.error("Error");
        }
    });
  }

  function sendMessage(leanBody, leanSenderName, leanSenderId, randUsers){
    var Inbox = Parse.Object.extend("Inbox");

    for(var i = 0; i < 3; ++i){

      var inbox = new Inbox();
      inbox.set("messageBody", leanBody);
      inbox.set("senderName",  leanSenderName);
      inbox.set("senderId", leanSenderId);
      inbox.set("recipientId", randUsers[i]);
      console.log("leanBody = " + leanBody);
      console.log("leanSenderName = " + leanSenderName);
      console.log("leanSenderId = " + leanSenderId);
      console.log("recipient = " + randUsers[i]);

      inbox.save(null, {
        success: function(inbox) {
          // Execute any logic that should take place after the object is saved.
          alert('New object created with objectId: ' + inbox.id);
        },
        error: function(inbox, error) {
          // Execute any logic that should take place if the save fails.
          // error is a Parse.Error with an error code and message.
          alert('Failed to create new object, with error code: ' + error.message);
        }
      });
    }
  }

函数varReset（leanBody、leanSenderName、leanSenderId、randUsers）{
leanBody=“”；
leanSenderName=“”；
leanSenderId=“”；
随机用户=[]；
log（“变量已设置”）；
}
Parse.Cloud.afterSave（“Lean”，函数（leanBody、leanSenderName、leanSenderId、randUsers、request）{
varReset（leanBody、leanSenderName、leanSenderId、randUsers）；
var query=newparse.query（“NewMessages”）；
第一个问题({
成功：功能（结果）{
leanBody=（results.get（“MessageBody”）；
leanSenderName=（results.get（“senderName”）；
leanSenderId=（results.get（“senderId”）；
getUsers（leanBody、leanSenderName、leanSenderId）；
结果：毁灭({
成功：功能（结果）{
控制台日志（“已删除”）；
}，错误：函数（结果，错误）{
}
});
}，错误：函数（错误）{
}
});
});
函数getUsers（leanBody、leanSenderName、leanSenderId、response）{
var query=newparse.query（Parse.User）；
查询.查找({
成功：功能（结果）{
var用户=[]；
console.log（leanBody）；
console.log（leanSenderName）；
//从结果中提取用户名
对于（变量i=0；i

你查过日志了吗？您可能会遇到资源限制（）。如果即时性不重要，那么设置一个每隔几分钟运行一次的后台作业并处理未传递的消息可能是值得的。也可以将这两种方法结合起来：让afterSave函数尝试立即传递到收件箱，而后台作业则定期接收任何剩余的新邮件。这不是最漂亮的解决方案，但至少你有一点更可靠。（你必须考虑比赛条件，尽管两人可能会在同一条新消息上尝试传递。）

关于您关于更好的结构的问题，如果两个类相同（或足够接近），是否可以只使用一个Messages类？最初，“收件人”字段将为空，但在beforeSave函数中分配了一个随机收件人。这可能更快更整洁

编辑：添加第三个最初是评论的观察：

我看到您在afterSave中使用了一个

Query.first（）

，以便找到需要处理的新消息。在调用afterSave和运行查询之间，可能会出现一条新消息。为什么不获取保存的新消息的ID并在查询中使用它，而不是

first（）

query.get（request.object.id，…）

这确保了afterSave中的代码处理调用它的新消息，而不是最近保存的消息。
你能发布相关的代码吗？
afterSave
不是应该这样：
Parse.Cloud.afterSave（“Comment”，function（request）{…}
？为什么回调有5个参数？第二个选项听起来确实好得多，但是我想将它发送给三个随机用户（为了简单起见，我省略了这个选项）因此，如果我在这方面使用beforeSave函数，我是否需要将原始邮件分配给一个随机收件人，然后再为其他两个收件人复制邮件的两个副本？允许列中的数组，因此您可以在“收件人”中的数组中潜在地存储3个收件人（即用户类的对象）列。我刚刚再次阅读了您的代码。我看到您正在使用afterSave中的Query.first（）来查找要处理的新消息。新消息可能具有