blocks|key|104087|text|function+timeout(funct,+args,+time)+{
++++var+deferred+=+new+jQuery.Deferred(),
++++++++promise+=+funct.apply(null,+args);

++++if+(promise)+{
++++++++$.when(promise)
++++++++++++.done(deferred.resolve)
++++++++++++.fail(deferred.reject)
++++++++++++.progress(deferred.notify);
++++}

++++setTimeout(function()+{
++++++++deferred.reject();
++++},+time);

++++return+deferred.promise();
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|104088|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function timeout(funct, args, time) {
 var deferred = new jQuery.Deferred(),
 promise = funct.apply(null, args);

 if (promise) {
 $.when(promise)
 .done(deferred.resolve)
 .fail(deferred.reject)
 .progress(deferred.notify);
 }

 setTimeout(function() {
 deferred.reject();
 }, time);

 return deferred.promise();
}
</code></pre>

blocks|key|104135|text|我知道这是两年前的事了，但如果有人在寻找答案……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|104136|我认为本杰明说得差不多，因为你想让你的超时单独处理，所以我们先从他的延迟功能开始。|104137|function+delay(ms){
++++var+d+=+$.Deferred();
++++setTimeout(function(){+d.resolve();+},+ms);
++++return+d.promise();
}|code-block|syntax|javascript|104138|然后，如果你想在代码执行之前等待，你可以调用你想要因为这个承诺而延迟的方法。|104139|function+timeout(funct,+args,+time)+{
++++return+delay(time).then(function(){
++++++++//+Execute+asynchronous+code+and+return+its+promise
++++++++//+instead+of+the+delay+promise.+Using+"when"+should
++++++++//+ensure+it+will+work+for+synchronous+functions+as+well.
++++++++return+$.when(funct.apply(null,+args));
++++});
}|104140|这通常是我在寻找复习课程时要做的事情(我来这里的原因)。然而，问题不在于延迟执行，而是在执行时间太长时抛出错误。在这种情况下，这会使事情变得复杂，因为您不想在没有必要的情况下等待超时，所以您不能只将这两个承诺包装在“何时”中。看起来我们还需要再推迟一次。(参见Wait+for+the+first+of+multiple+jQuery+Deferreds+to+be+resolved?)|offset|length|104141|function+timeout(funct,+args,+time)+{
++++var+d+=+$.Deferred();

++++//+Call+the+potentially+async+funct+and+hold+onto+its+promise.
++++var+functPromise+=+$.when(funct.apply(null,+args));

++++//+pass+the+result+of+the+funct+to+the+master+defer
++++functPromise.always(function(){
++++++++d.resolve(functPromise)
++++});

++++//+reject+the+master+defer+if+the+timeout+completes+before
++++//+the+functPromise+resolves+it+one+way+or+another
++++delay(time).then(function(){
++++++++d.reject('timeout');
++++});

++++//+To+make+sure+the+functPromise+gets+used+if+it+finishes
++++//+first,+use+"then"+to+return+the+original+functPromise.
++++return+d.then(function(result){
++++++++return+result;
++++});
}|104142|我们可以简化这一过程，因为我们知道在这种情况下，主延迟只会在超时首先发生的情况下才会拒绝，并且只有在functPromise首先解决时才会解决。正因为如此，我们不需要将functPromise传递给主延迟解析，因为它是唯一可以传递的东西，并且我们仍然在作用域中。|104143|function+timeout(funct,+args,+time)+{
++++var+d+=+$.Deferred();

++++//+Call+the+potentially+async+funct+and+hold+onto+its+promise.
++++var+functPromise+=+$.when(funct.apply(null,+args))
++++++++.always(d.resolve);

++++//+reject+the+master+defer+if+the+timeout+completes+before
++++//+the+functPromise+resolves+it+one+way+or+another
++++delay(time).then(function(){
++++++++d.reject('timeout');
++++});

++++//+To+make+sure+the+functPromise+gets+used+if+it+finishes
++++//+first,+use+"then"+to+return+the+original+functPromise.
++++return+d.then(function(){
++++++++return+functPromise;
++++});
}|104144|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/11977192/wait-for-the-first-of-multiple-jquery-deferreds-to-be-resolved^0|0|0|0|0|0|3M|1R|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|17|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|19|8|@]|9|@$O|1A|P|1B|1|1C]]|A|$]]|$1|Q|3|R|5|F|7|1D|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|1E|8|@]|9|@]|A|$]]|$1|U|3|V|5|F|7|1F|8|@]|9|@]|A|$G|H]]|$1|W|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]]]

I realize this is 2 years old, but in case someone is looking for the answer...

I think Benjamin was close in that you'll want your timeout to be handled separately, so we'll start with his delay function.

<pre><code>function delay(ms){
 var d = $.Deferred();
 setTimeout(function(){ d.resolve(); }, ms);
 return d.promise();
}
</code></pre>

Then, if you wanted to wait before code is executed you can call the method you want delayed as a result of this promise.

<pre><code>function timeout(funct, args, time) {
 return delay(time).then(function(){
 // Execute asynchronous code and return its promise
 // instead of the delay promise. Using "when" should
 // ensure it will work for synchronous functions as well.
 return $.when(funct.apply(null, args));
 });
}
</code></pre>

This is usually what I'm trying to do when I go looking for a refresher (why I'm here). However, the question was not about delaying the execution, but throwing an error if it took too long. In that case, this complicates things because you don't want to wait around for the timeout if you don't have to, so you can't just wrap the two promises in a "when". Looks like we need another deferred in the mix. (See <a href="https://stackoverflow.com/questions/11977192/wait-for-the-first-of-multiple-jquery-deferreds-to-be-resolved">Wait for the first of multiple jQuery Deferreds to be resolved?</a>)

<pre><code>function timeout(funct, args, time) {
 var d = $.Deferred();

 // Call the potentially async funct and hold onto its promise.
 var functPromise = $.when(funct.apply(null, args));

 // pass the result of the funct to the master defer
 functPromise.always(function(){
 d.resolve(functPromise)
 });

 // reject the master defer if the timeout completes before
 // the functPromise resolves it one way or another
 delay(time).then(function(){
 d.reject('timeout');
 });

 // To make sure the functPromise gets used if it finishes
 // first, use "then" to return the original functPromise.
 return d.then(function(result){
 return result;
 });
}
</code></pre>

We can streamline this, knowing that in this case the master defer only rejects if the timeout happens first and only resolves if the functPromise resolves first. Because of this, we don't need to pass the functPromise to the master defer resolve, because it's the only thing that could be passed and we're still in scope.

<pre><code>function timeout(funct, args, time) {
 var d = $.Deferred();

 // Call the potentially async funct and hold onto its promise.
 var functPromise = $.when(funct.apply(null, args))
 .always(d.resolve);

 // reject the master defer if the timeout completes before
 // the functPromise resolves it one way or another
 delay(time).then(function(){
 d.reject('timeout');
 });

 // To make sure the functPromise gets used if it finishes
 // first, use "then" to return the original functPromise.
 return d.then(function(){
 return functPromise;
 });
}
</code></pre>

It's a common pattern to implement timeout of some asynchronous function, using deffered/promise:

<pre><code>// Create a Deferred and return its Promise
function timeout(funct, args, time) {
 var dfd = new jQuery.Deferred();

 // execute asynchronous code
 funct.apply(null, args);

 // When the asynchronous code is completed, resolve the Deferred:
 dfd.resolve('success');

 setTimeout(function() {
 dfd.reject('sorry');
 }, time);
 return dfd.promise();
}
</code></pre>

Now we can execute some asynchronous function called <code>myFunc</code> and handle timeout:

<pre><code>// Attach a done and fail handler for the asyncEvent
$.when( timeout(myFunc, [some_args], 1000) ).then(
 function(status) {
 alert( status + ', things are going well' );
 },
 function(status) {
 alert( status + ', you fail this time' );
 }
);
</code></pre>

OK, let's make a twist in this story! Imagine that the <code>myFunc</code> itself returns a promise (NOTE: promise NOT deferred and I can't change it):

<pre><code>function myFunc(){
 var dfd = new jQuery.Deffered();
 superImportantLibrary.doSomething(function(data)){
 if(data.length &lt; 5){
 dfd.reject('too few data');
 }
 else{
 dfd.resolve('success!');
 }
 }, {'error_callback': function(){
 dfd.reject("there was something wrong but it wasn't timeout");}
 }});
 return dfd.promise();
}
</code></pre>

Now if I wrap <code>myFunc</code> in <code>timeout</code>, I will loose the ability to handle errors different then timeout. If <code>myFunc</code> emit progress events, I will loose this as well.

So the question is: how to modify <code>timeout</code> function so it can accept functions returning promises without loosing their errors/progress information?

in JavaScript, how to wrap a promise in timeout?

jQuery

实现某些异步函数超时是一种常见模式，使用deffered/promise：// Create a Deferred and return its Promisefunction timeout(funct, args, time) {    var dfd = new jQuery.Deferred();    // ...

问在JavaScript中，如何在超时中包装承诺？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在JavaScript中，如何在超时中包装承诺？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在JavaScript中，如何在超时中包装承诺？
EN