如何在JavaScript中实现由时钟解析的monad承诺？

在观看时，我对52:40被问到的一个问题感兴趣。如何使用monad实现看门狗计时器，以便在调用失败函数之前，承诺可以保持或仅在一段可定义的时间内处于挂起状态。这个模式有一个普遍接受的名称吗？

没有，杰森。 看看Crockford在GitHub上的实现，它没有适合这种行为的钩子

也就是说，在一个典型的Promise范例中，有比Crockford代码授予的更多的选项

看看AJAX库。尽管很多人不知道，但很多AJAX库（包括jQuery）都会回报承诺

要在他的代码中实现这一点，您可以在一个带有计时器的子句中挂钩，该计时器根据与承诺的参数一起提交的时间来打破承诺

否则，您可以执行以下操作：

var vow = VOW.make(),

    last_promise = vow.when()
                      .when()
                      .when()
                      .when() /*...*/;


(function () {
    var vow = VOW.make(),
        time_over = false,
        time_limit = 30 * 1000,
        timer_handle,

        success = function (value) {
            if (time_over) { vow["break"]("Time's up!"); }
            else {
                clearInterval(timer_handle);
                vow.keep(value);
            }
        };

    trailing_promise.when(success, /* fail */);

    return vow.promise;

}()).when(/* ... */)
    .when()
    .when();

我认为，类似的东西应该与那里提供的东西配合使用

就我个人而言，在看过他的演讲并阅读了他的实现之后，我认为我更喜欢承诺保持他们的线性队列函数（

done

，

fail

或

success/fail

或

ready/fail

或其他），但我所看到的大多数库都是临时队列（

when

，

next

，等等）与承诺分离

所以这里有两个相互竞争的队列，真的。一个是订阅事件（如

.addEventListener

：当操作发生时，所有侦听器都会同时被调用），另一个是订阅下一个结果的最终返回（如收听订阅EventListener的内容）

在Crockford的最小实现中，更像是您只能有一个侦听器，然后订阅者侦听上一个订阅者的上一个订阅者的最后一个订阅者

…将多条指令链接到同一队列中的唯一方法是缓存返回：

var level_0 = VOW.make(),
    level_1 = level_0.when(/* ... , ... */),
    level_2 = level_1.when(/* ... , ... */);


level_1.when(/* more stuff */);
level_1.when(/* even more  */);


level_2.when()
       .when()
       .when();


// ...eventually.......

level_0.keep("stuff");

没有，杰森。 看看Crockford在GitHub上的实现，它没有适合这种行为的钩子

也就是说，在一个典型的Promise范例中，有比Crockford代码授予的更多的选项

看看AJAX库。尽管很多人不知道，但很多AJAX库（包括jQuery）都会回报承诺

要在他的代码中实现这一点，您可以在一个带有计时器的子句中挂钩，该计时器根据与承诺的参数一起提交的时间来打破承诺

否则，您可以执行以下操作：

var vow = VOW.make(),

    last_promise = vow.when()
                      .when()
                      .when()
                      .when() /*...*/;


(function () {
    var vow = VOW.make(),
        time_over = false,
        time_limit = 30 * 1000,
        timer_handle,

        success = function (value) {
            if (time_over) { vow["break"]("Time's up!"); }
            else {
                clearInterval(timer_handle);
                vow.keep(value);
            }
        };

    trailing_promise.when(success, /* fail */);

    return vow.promise;

}()).when(/* ... */)
    .when()
    .when();

我认为，类似的东西应该与那里提供的东西配合使用

就我个人而言，在看过他的演讲并阅读了他的实现之后，我认为我更喜欢承诺保持他们的线性队列函数（

done

，

fail

或

success/fail

或

ready/fail

或其他），但我所看到的大多数库都是临时队列（

when

，

next

，等等）与承诺分离

所以这里有两个相互竞争的队列，真的。一个是订阅事件（如

.addEventListener

：当操作发生时，所有侦听器都会同时被调用），另一个是订阅下一个结果的最终返回（如收听订阅EventListener的内容）

在Crockford的最小实现中，更像是您只能有一个侦听器，然后订阅者侦听上一个订阅者的上一个订阅者的最后一个订阅者

…将多条指令链接到同一队列中的唯一方法是缓存返回：

var level_0 = VOW.make(),
    level_1 = level_0.when(/* ... , ... */),
    level_2 = level_1.when(/* ... , ... */);


level_1.when(/* more stuff */);
level_1.when(/* even more  */);


level_2.when()
       .when()
       .when();


// ...eventually.......

level_0.keep("stuff");

---

我一直在使用jQuery的延迟方法（虽然我找不到一个语句，但我认为它是一元的），它看起来可以工作（a）（这看起来太简单了）

在JSFIDLE中使用的示例如下：

console.log("Waiting 2,000ms for something we think will take 3,000ms to return");
watchdog(
  $.post('/echo/html/', { delay: 3 })
   .done(function() {console.log("Got It!");})
   .fail(function() {console.log('took too long (but I knew that)!');})
   .always(function() {console.log('Cleaning up no matter what');})
  , 2000);

console.log("Waiting 3,000ms for something we think will take 2,000ms to return");
watchdog(
  $.post('/echo/html/', { delay: 2 })
   .done(function() {console.log("Got It (but I knew that)!");})
   .fail(function() {console.log('took too long!');})
   .always(function() {console.log('Cleaning up no matter what');})
  , 3000);

这是生成的日志：

Waiting 2,000ms for something we think will take 3,000ms to return
Waiting 3,000ms for something we think will take 2,000ms to return

took too long (but I knew that)!
Cleaning up no matter what
Got It (but I knew that)!
Cleaning up no matter what

---

我一直在使用jQuery的延迟方法（虽然我找不到一个语句，但我认为它是一元的），它看起来可以工作（a）（这看起来太简单了）

在JSFIDLE中使用的示例如下：

console.log("Waiting 2,000ms for something we think will take 3,000ms to return");
watchdog(
  $.post('/echo/html/', { delay: 3 })
   .done(function() {console.log("Got It!");})
   .fail(function() {console.log('took too long (but I knew that)!');})
   .always(function() {console.log('Cleaning up no matter what');})
  , 2000);

console.log("Waiting 3,000ms for something we think will take 2,000ms to return");
watchdog(
  $.post('/echo/html/', { delay: 2 })
   .done(function() {console.log("Got It (but I knew that)!");})
   .fail(function() {console.log('took too long!');})
   .always(function() {console.log('Cleaning up no matter what');})
  , 3000);

这是生成的日志：

Waiting 2,000ms for something we think will take 3,000ms to return
Waiting 3,000ms for something we think will take 2,000ms to return

took too long (but I knew that)!
Cleaning up no matter what
Got It (but I knew that)!
Cleaning up no matter what

---

这是可行的，因为一旦承诺得到遵守，就不能被打破，因此如果承诺成功，它将从“挂起”变为“保持”，如果首先调用超时，它将从“挂起”变为“打破”。但我对monad的了解还不够，无法理解这是否是一个正确的实现。这是可行的，因为一旦它遵守了承诺就不能被打破，因此如果承诺成功，它将从“挂起”变为“保持”，如果先调用超时，它将从“挂起”变为“打破”。但我对monad的了解还不够，无法理解这是否是一个正确的实现。虽然我喜欢我自己的答案，但我的答案不是真正的monad，正如我喜欢我自己的答案一样，我的答案不是真正的monad