Parse platform Parse.com-Promises-返回父对象和其他一对一对象作为属性

我有两个表在解析中

---

具有一对一关系的内存和位置，但指针位于位置表中（指针）

我需要的是用skip和limit十个十个地读取所有内存，并用location对象为每个内存分配一个属性

现在我有了这个：

var _ = require('underscore.js');
Parse.Cloud.define("feed", function(request, response) {
    var memories = Parse.Object.extend("Memories");
    var memoriesQuery = new Parse.Query(memories);

    memoriesQuery.skip(0);//request.params.skip);
    memoriesQuery.limit(10);//request.params.limit);
    memoriesQuery.descending("createdAt");
    memoriesQuery.include("group");

    var parsedResults = [];

    memoriesQuery.find().then(function(memories) {

        var promise = Parse.Promise.as();
        _.each(memories, function(memory) {

            promise = promise.then(function() {
                var locations = Parse.Object.extend("Locations");
                var locationsQuery = new Parse.Query(locations);
                locationsQuery.equalTo("memory", memory);

                var subPromise = Parse.Promise();

                locationsQuery.first().then(function(location) {
                    memory["location"] = location;
                    console.log(JSON.stringify(memory) + " ........ " + memory["location"]);
                    console.log("=============");
                    parsedResults.push(memory);
                    subPromise.resolve(memory);
                });
                return subPromise ;
            });
            console.log("-----------");
            console.log("Promise:" +promise.toString());
        });

        return promise;

    }).then(function(){
        response.success(parsedResults);
    });
});

我不知道该怎么办。。超过10个小时的尝试。 谢谢你的帮助

终于解决了！ 也许它会帮助别人

解决方案：

var _ = require('underscore.js');
var memoriesResult = [];
Parse.Cloud.define("feed", function(request, response) {
    var promises = [];
    var promise = findMemories();
    promise.then(function(memories){
        console.log("success promise!!");
        _.each(memories, function (memory) {
            console.log("each");
            promises.push(findLocation(memory));
        });
        return Parse.Promise.when(promises);
    }).then(function(){
        console.log("Finish");
        response.success(memoriesResult);
    }, function(error){
        console.error("Promise Error: " + error.message);
        response.error(error);
    });
});

function findMemories(){
    console.log("Enter findMemories");

    var memories = Parse.Object.extend("Memories");
    var memoriesQuery = new Parse.Query(memories);

    memoriesQuery.skip(0);//request.params.skip);
    memoriesQuery.limit(10);//request.params.limit);
    memoriesQuery.descending("createdAt");
    memoriesQuery.include("group");

    var promise = new Parse.Promise();

    memoriesQuery.find().then(function(memories) {
        console.log("Memories found!");
        promise.resolve(memories);
    }, function(error) {
        promise.reject(error);
    });
    return promise;
}

function findLocation(memory) {
    console.log("Enter findLocation");

    var locations = Parse.Object.extend("Locations");
    var locationsQuery = new Parse.Query(locations);
    locationsQuery.equalTo("memory", memory);

    var promise = new Parse.Promise();

    locationsQuery.first().then(function(location) {
        console.log("Location found");
        memoriesResult.push({"memory": memory, "location" : location});
        promise.resolve(memory);
    }, function(error) {
        promise.reject(error);
    });
    return promise;
}

---

在做了一些实验之后，我提出了以下要求和解决方案：

• 您希望一次翻页一页地浏览

  内存

  项，按它们的

  createdAt

• 您需要与每个内存相关的

  位置

• 您受到以下事实的限制：关系是

  Locations->Memories

第一步是定义内存查询：

var memoryQuery = new Parse.Query('Memories');
memoryQuery.skip(request.params.skip);
memoryQuery.skip(request.params.limit);
memoryQuery.descending('createdAt');

现在可以使用此查询来限制返回的

位置

对象。如果链接设置正确，您将返回10条记录：

var locationQuery = new Parse.Query('Locations');
// limit to only the page of Memory items requested
locationQuery.matchesQuery('memory', memoryQuery);
// include the Memory pointer's data
locationQuery.include('memory');
var memoriesResult = [];
locationQuery.find().then(function(locations) {
    var result = _.map(locations, function(location) {
        memory: location.get('memory'),
        location: location
    });
    response.success(result);
}, function(error) {
    response.error(error);
});

上面提到的唯一问题是，我不确定返回记录的顺序，因此您可能希望在返回它们之前对它们重新排序。虽然使用下划线库，但这非常简单

---

无论页面大小如何，这将导致2次查询。

但指针位于位置表（指针）。。。然后，您应该在字段名中包含指向内存的指针的include来查询“location”。我需要这种方式，因为location是我需要连接的表之一，但我还有两个一对多的表，如果我得到了.first（）的解决方案，那么就很容易为.find（）创建。这就是我需要的解决方法，我强烈建议不要在循环中执行另一个

find（）

，因为这样做确实不能很好地扩展。您将执行大量查询（如果

request.params.limit==10

您将执行11个查询）True。但是除了位置表wich是一对一之外，我还有两个wich是一对多，我使用的不是.first（）方法，而是.find（），在那里我不能使用你的方法。感谢您抽出时间回答！