Parse platform 递归查询在Parse.cloud之外获得1000多个结果不可能？

我需要从一个类中获取1000多个元素

所以我试着按照建议去做，但有些东西不正常，我已经花了一整天的时间来寻找解决办法

Parse.Cloud.define("getFollow", function(request, response) {
    var following = [];
    var user = request.params.user;
    user.fetch().then(function(result) {
        if (!result.get('following')) {
            following = getFollowing({
                'user': user
            });
        } 
    }).then(function() {    
        response.success(following);
    }, function(error) {
        response.error(error);
    });
});

function getFollowing(request) {
    var count = 0;
    var skip = request.skip || 0;
    var limit = 1000;
    var following = request.following || [];
    var Follow = Parse.Object.extend('follow');
    var query = new Parse.Query(Follow);
    query.limit(limit); 
    query.ascending('objectId');
    query.skip(skip * limit);   
    query.equalTo('followers', request.user);
    query.find().then(function(results) {

        skip+= 1;
        count = results.length;

/* I can't see any DEBUG, seems nothing is queried */

console.log('[DEBUG] Check <count>: ' + count);  


        return Parse.Promise.when(results.map(function(result) {
            following.push(result.get('followed')); 
        }));        
    }).then(function() {            
        if(count >= limit) {
            following = getFollowingUsers({
                'user': request.user,
                'skip': skip,
                'following': following
            });         
        } 
    }).then(function() {    
        return following;
    }, function(error) {
        return error;
    });
}

Parse.Cloud.define（“getFollow”），函数（请求、响应）{
var following=[]；
var user=request.params.user；
user.fetch（）.then（函数（结果）{
如果（！result.get（'following'））{
following=getFollowing({
“用户”：用户
});
} 
}).then（函数（）{
答复：成功（以下）；
}，函数（错误）{
响应。错误（error）；
});
});
函数getFollowing（请求）{
var计数=0；
var skip=request.skip | | 0；
var限值=1000；
var following=request.following | |[]；
var Follow=Parse.Object.extend（'Follow'）；
var query=newparse.query（Follow）；
查询.限额（limit）；
升序（'objectId'）；
查询.跳过（跳过*限制）；
query.equalTo（'followers'，request.user）；
query.find（）.then（函数（结果）{
skip+=1；
计数=结果长度；
/*我看不到任何调试，似乎没有任何问题*/
console.log（“[DEBUG]检查：”+count）；
返回Parse.Promise.when（results.map）（函数（result）{
following.push（result.get（'followind'））；
}));        
}).then（函数（）{
如果（计数>=限制）{
following=getfollowing用户({
“用户”：request.user，
“跳过”：跳过，
“跟随”：跟随
});         
} 
}).then（函数（）{
返回跟踪；
}，函数（错误）{
返回误差；
});
}

我尝试了这段代码的许多变体，试图返回查询的第一个结果，而不是一个集合。我还试图删除所有的禁忌，但即使如此，我的查询似乎也无法运行

我还尝试使用Cloud.code函数，仅使用Parse.Cloud递归地实现这一点，但如果我这样做，我会收到一条消息，即对云代码的递归调用太多

---

我在这个逻辑上做错了什么？

我从来没有处理过这个问题，但是你不能只使用

query.each（）

，然后，像这样，增加一个数组吗？每个都将被限制为1000个结果。我非常确定每个（）不像find（）那样受到限制。可能是错的。我从来没有处理过这个问题，但你不能只使用

查询。each（）

和，像，增长一个数组吗？每个都将被限制为1000个结果。我非常确定，每个（）不像find（）那样被限制。可能是错的。