Javascript AngularJS：解决自链接承诺

我知道承诺是可以链接的，如本例所示：

// we also have deferA, deferB and deferC as the corresponding defer objects
promiseB = promiseA.then(function(result) {
    // do stuff to resolve B
});

promiseC = promiseB.then(function(result) {
    // do stuff to resolve C
});

现在，如果我调用

delera.resolve（data）

这将解析

promiseA

，它的

方法将运行，然后
promiseB
被解析。最后promiseB的
将运行并解析
promiseC
。平淡而简单（希望我没弄错）

然而，如果一个承诺与它自身相关联，会发生什么呢

如果我将上述示例更改为：

// we also have deferA and deferB as the corresponding defer objects
promiseA = promiseA.then(function(result) {
    // do stuff to...?
});

promiseB = promiseA.then(function(result) {
    // do stuff to resolve B
});

deferA.resolve(data);

// we also have deferA and deferB as the corresponding defer objects
promiseA = promiseA.then(function(result) {
    // do stuff to...?
});

deferA.resolve(data);

promiseB = promiseA.then(function(result) {
    // do stuff to resolve B
});

现在发生了什么？执行的顺序是什么

再讲一遍，这个怎么样：

// we also have deferA and deferB as the corresponding defer objects
promiseA = promiseA.then(function(result) {
    // do stuff to...?
});

promiseB = promiseA.then(function(result) {
    // do stuff to resolve B
});

deferA.resolve(data);

// we also have deferA and deferB as the corresponding defer objects
promiseA = promiseA.then(function(result) {
    // do stuff to...?
});

deferA.resolve(data);

promiseB = promiseA.then(function(result) {
    // do stuff to resolve B
});

在这种情况下会发生什么？
这不是承诺，而是JavaScript中的引用

当您这样做时：

p = p.then(function(){...

您正在更改
p
所指的承诺，您没有更改延迟对象在您填写/拒绝它时将解决的承诺-这与您被分配给它之前的
p
仍然相同。因此，在您的示例代码中：

promiseA = promiseA.then(function(result) { // THIS WILL EXECUTE FIRST
    // do stuff to...?
});

promiseB = promiseA.then(function(result) { // THIS WILL EXECUTE SECOND
    // do stuff to resolve B
});

deferA.resolve(data);


当您将多个
附加到承诺时，则将
处理程序附加到承诺，如中所示：

var p = first.then(...

var p2 = first.then(...

我在这里假设一个承诺/a+实现。规范保证两个
。然后
处理程序在
第一次
完成时执行。它总是按照它们被添加的顺序发生

因此，在上述情况下：


第一个允诺人将解决
然后，上面的promiseA.Then将运行（首先添加的promiseA）
然后底部的promiseA.Then将运行（稍后添加的promiseA.Then）

在
之前或之后解决延迟。然后添加
不会以明显的方式改变结果（琐事：jQuery承诺不是这种情况，这是一个很大的问题）


不过，创建一个循环承诺链是可能的，只是稍微难一点。就像可以创建一个无限循环一样。Good promise库要么运行它，要么抛出循环引用错误。
这不是关于promise，而是关于JavaScript中的引用

当您这样做时：

p = p.then(function(){...

您正在更改
p
所指的承诺，您没有更改延迟对象在您填写/拒绝它时将解决的承诺-这与您被分配给它之前的
p
仍然相同。因此，在您的示例代码中：

promiseA = promiseA.then(function(result) { // THIS WILL EXECUTE FIRST
    // do stuff to...?
});

promiseB = promiseA.then(function(result) { // THIS WILL EXECUTE SECOND
    // do stuff to resolve B
});

deferA.resolve(data);


当您将多个
附加到承诺时，则将
处理程序附加到承诺，如中所示：

var p = first.then(...

var p2 = first.then(...

我在这里假设一个承诺/a+实现。规范保证两个
。然后
处理程序在
第一次
完成时执行。它总是按照它们被添加的顺序发生

因此，在上述情况下：


第一个允诺人将解决
然后，上面的promiseA.Then将运行（首先添加的promiseA）
然后底部的promiseA.Then将运行（稍后添加的promiseA.Then）

在
之前或之后解决延迟。然后添加
不会以明显的方式改变结果（琐事：jQuery承诺不是这种情况，这是一个很大的问题）


不过，创建一个循环承诺链是可能的，只是稍微难一点。就像可以创建一个无限循环一样。Good promise库要么运行它，要么抛出循环引用错误。
会发生什么
。。你不能将这些记录到控制台并找出答案吗？@charlietfl当然可以，但我问的是它背后的逻辑和顺序。
会发生什么
。。你不能将这些记录到控制台并找出答案吗？@charlietfl当然可以，但我问的是它背后的逻辑和顺序。那么关于引用，如果我写
deferA.promiseA=deferA.promiseA。然后（…）
？这肯定会改变延迟对象。@Xavier_Ex，这取决于延迟实现-这类事情（以及抛出安全性）就是为什么有些库使用
.promise（）
，而有些库不使用更好的promise构造函数直接访问延迟对象。因为您标记了它，所以可以看到的是的resolve方法（只是它的.promise值），因为它是闭包绑定的。尽管如此，您还是应该避免这种情况，这可能会在将来的角度更新中发生变化。在您的示例中，您有
p=first.then（）
和
p2=first.then（）
，您说这两个
.then（）
处理程序都将在
first
解析后运行，并且它们将按顺序运行。这与
first.then（）.then（）
相同吗？或者这两个
.then（）
处理程序是同步运行的（第二个处理程序不等待第一个处理程序解析，它只等待回调返回）？我的问题清楚了吗？如果您不重新分配promiseA，两个
。然后
处理程序按顺序同步运行，如果您重新分配promiseA，则它们异步运行。然后（…）；promiseA.then（…）
按照您附加处理程序的顺序。那么关于引用，如果我编写
deferA.promiseA=deferA.promiseA.then（…）
？这肯定会改变延迟对象。@Xavier_Ex，这取决于延迟实现-这类事情（以及抛出安全性）就是为什么有些库使用
.promise（）
，而有些库不使用更好的promise构造函数直接访问延迟对象。因为您标记了它，所以可以看到的是的resolve方法（只是它的.promise值），因为它是闭包绑定的。尽管如此，您还是应该避免这种情况，这可能会在将来的角度更新中发生变化。在您的示例中，您有
p=first.then（）
和
p2=first.then（）
，您说这两个
.then（）
处理程序都将在
first
解析后运行，并且它们将按顺序运行。这与
first.then（）.then（）
相同吗？或者这两个
.then（）
处理程序是同步运行的（第二个处理程序不等待第一个处理程序解析，它只等待回调返回）？我的问题清楚了吗？两个