Javascript Parse.com的云代码应该如何处理异步？

我拼命寻找这个问题的答案，好不容易才找到了答案。希望其他人能从我失去的时间中得到拯救。也许有人会用改进或更好的模式来回答

编辑：我在此输入的一组早期代码已被替换

在这个方法中，您可以看到如何在没有回调嵌套的情况下对异步操作进行多次调用。它还展示了如何将异步代码放入更小的可调用函数中。该方法还可以在多个层次上调用异步函数。在每个级别上，可以将多个异步操作串在一起以满足其意图。错误可以沿行向上传递，并且可以在.thens序列中冒泡

日志输出应有助于了解实际情况

作为一名parse和JS初学者，有两件事对我很有帮助：1）parse JS操作在返回承诺时似乎是异步的，否则就不是了，一个例外是query.get（）。2） 请非常小心.then调用的语法。3） 抛出的错误将不会被.then error函数捕获。要引起错误，请使用“return Parse.Promise.error（）”。4） 要理解承诺，请观看Mike Taulty的视频，很容易用谷歌搜索到，谢谢Mike

这段代码已经在Parse.com上进行了测试

function test0()
{
    console.log("test0.entry");
    var promise0 = test1("T", "col", "test1call1");

    var promise1 = promise0.then(function(ex) {
        console.log("test0.0.success - " + ex);
        return test1("T", "emailAddress", "test1call2");
    });
    var promise2 = promise1.then(function(ex) {
        console.log("test0.1.success - " + ex);
        return test2(1);
    });
    promise2.then(function(msg) {
        console.log("test0.2.success - " + msg);
        return;
    }, function(error) {
        console.log("test0.2.error " + error.message);
        return;
    });
    console.log("test0.exit");
}

function test1(clss, col, val) 
// use as a method on a save request
// returns true if the column value already exists
{
    console.log("[" + val + "]" + "test1.entry");
    var c = Parse.Object.extend(clss);
    var query = new Parse.Query(c);

    query.equalTo(col, val);
    var promise1 = query.count();
    var promise2 = promise1.then(function(count) {
        console.log("[" + val + "]" + "test1.sub.success - " + count);
        if (col == "reject") {    
            var err = new Parse.Error(10001, "new test error");
            console.log("[" + val + "]" + "test1.sub.success - return test error");
            return Parse.Promise.error(new Parse.Error(10001, "test error (10001)"));
        } 
        return(count>0);
    }, function(error) {
        console.log("[" + val + "]" + "test1.sub.error " + error.get("message"));
        return(false);
    });
    console.log("[" + val + "]" + "test1.return");
    return promise2;
};

function test2(n) 
// use as a method on a save request
// returns true if the column value already exists
{
    console.log("test2.entry");
    var c = Parse.Object.extend("T");
    var query = new Parse.Query(c);

    query.equalTo("col", "val");
    var promise1 = query.count();
    var promise2 = promise1.then(function(count) {
        console.log("test2.promise1.success - " + count);
        if (n==1) {
            return test1("T", "reject", "test2call1e");
        } else {
            return test1("T", "col", "test2call1");
        }
    });

    var promise3 = promise2.then(function(count) {
        console.log("test2.promise1.success - " + count);
        if (n==2) {
            return test1("T", "reject", "test2call2e");
        } else {
            return test1("T", "col", "test2call2");
        }
    });

    var promise4 = promise3.then(function() {
        console.log("test2.promise3.success - " + count);
        return "test2 completed";
    }, function(error) {
        // Catch some errors here and repair them
        console.log("test2.promise3.error - " + error.message);
        return Parse.Promise.as("test2 completed - error repaired");
    });

    console.log("test2.exit");
    return promise4;
};

它产生了这个输出

I2013-03-30T01:58:19.983Z] test0.entry
I2013-03-30T01:58:19.983Z] [test1call1]test1.entry
I2013-03-30T01:58:19.984Z] [test1call1]test1.return
I2013-03-30T01:58:19.984Z] test0.exit
I2013-03-30T01:58:20.085Z] [test1call1]test1.sub.success - 0
I2013-03-30T01:58:20.085Z] test0.0.success - false
I2013-03-30T01:58:20.085Z] [test1call2]test1.entry
I2013-03-30T01:58:20.085Z] [test1call2]test1.return
I2013-03-30T01:58:20.186Z] [test1call2]test1.sub.success - 0
I2013-03-30T01:58:20.186Z] test0.1.success - false
I2013-03-30T01:58:20.186Z] test2.entry
I2013-03-30T01:58:20.187Z] test2.exit
I2013-03-30T01:58:20.338Z] test2.promise1.success - 0
I2013-03-30T01:58:20.338Z] [test2call1e]test1.entry
I2013-03-30T01:58:20.338Z] [test2call1e]test1.return
I2013-03-30T01:58:20.439Z] [test2call1e]test1.sub.success - 0
I2013-03-30T01:58:20.439Z] [test2call1e]test1.sub.success - return test error
I2013-03-30T01:58:20.439Z] test2.promise3.error - test error (10001)
I2013-03-30T01:58:20.439Z] test0.2.success - test2 completed - error repaired

---

如果将许多都是内联函数的函数链接在一起，那么在解析中使用承诺会变得更加困难。我所做的是将每个操作定义为一个函数，然后将它们链接在一起，并使用

handleSuccess

和

handleError

完成最后一个块。这样，每个函数都是自包含的，易于理解，而链式序列是有组织的，易于更新

fetchThing

和

updateThing

函数都返回一个包含

thing

实例的承诺。获取的值被传递给更新函数，然后更新函数被传递给链式序列中的下一个函数

var fetchThing = function(objectId) {
    // set up a query with objectId
    return query.find();
};

var updateThing = function(thing) {
    // set properties on thing
    return thing.save();
}

var handleSuccess = function(result) {
    response.success(result);
};

var handleError = function(error) {
    response.error(error);
};

var objectId = 'asdfad';

fetchThing(objectId).then(function(thing) {
    return updateThing(thing);
}).then(handleSuccess, handleError);

我在GitHub上创建了一个完整的示例，它使用云代码和承诺的这种编程风格

---

欢迎来到StackOverflow。请将您的答案作为答案发布（您可以在冷静期后接受自己的答案），并将您的问题改写为问题。