blocks|key|1660663|text|在每个请求的回调函数上，设置一个布尔值，例如|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1660664|request1Complete和request2Complete|offset|length|style|CODE|1660665|然后打电话给on_both_requests_complete(resp1,resp2)。|1660666|在处理函数中，检查是否设置了两个布尔值。如果不是，就返回并退出函数。回调函数应该是序列化的，因为它们不能同时发生，所以这应该是可行的。如果它们可以并行发生，您将在竞争条件下中断。|1660667|entityMap^0|0|0|G|H|G|0|6|12|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@$D|P|E|Q|F|G]|$D|R|E|S|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@$D|U|E|V|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|W|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|M|$]]

On the callback function of each request, set a boolean such as 

<code>request1Complete</code> and <code>request2Complete</code>

and call <code>on_both_requests_complete(resp1,resp2)</code>.

In the handler function, check to see if both booleans are set. If not, just return and fall out of the function. The callback functions should be serialized, in that they cannot happen simultaneously, so this should work. If they could happen in parallel, you would break on a race condition.

blocks|key|1660684|text|您必须记住，浏览器中的JS实现并不是真正的并发，并利用这一点对您有利。因此，您要做的是在每个处理程序中检查其他处理程序是否已完成。jQuery中的示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1660685|var+other_done+=+false;
$.get('/one',+function()+{
++if+(other_done)+both_completed();
++other_done+=+true;
++alert('One!');
});
$.get('/two',+function()+{
++if+(other_done)+both_completed();
++other_done+=+true;
++alert('Two!');
});
function+both_completed()+{
++alert('Both!');
}|code-block|syntax|javascript|1660686|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Well, you have to remember that the JS implementation in browsers is not really concurrent, and use that to your advantage. So what you would want to do is in each handler check if the other has finished. Example in jQuery:

<pre><code>var other_done = false;
$.get('/one', function() {
 if (other_done) both_completed();
 other_done = true;
 alert('One!');
});
$.get('/two', function() {
 if (other_done) both_completed();
 other_done = true;
 alert('Two!');
});
function both_completed() {
 alert('Both!');
}
</code></pre>

blocks|key|3976758|text|您可以使用设置临时变量并等待“最后”请求执行的概念。为此，您可以让这两个句柄函数将tmp变量设置为返回val，然后调用"on_both_requests_complete“函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3976759|var+processed+=+false;
var+r1+=+new+Ajax.Request(...);
var+r2+=+new+Ajax.Request(...);

(function()+{
+var+data1;
+var+data2;

+function+handle_r1(data)+{
+++data1+=+data;
+++on_both_requests_complete();+
+};

+function+handle_r2(data)+{
+++data2+=+data;
+++on_both_requests_complete();
+};

+function+on_both_requests_complete()+{
++if+(+(!data1+%7C%7C+!data2)+%7C%7C+processed)+{
++++return;
++}
++processed+=+true;

++/*+do+something+*/
+};
}();|code-block|syntax|javascript|3976760|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can use the concept where you set temporary variables and wait for the "last" request to go. To do this, you can have the two handle functions set the tmp vars to the return val and then call your "on_both_requests_complete" function.

<pre><code>var processed = false;
var r1 = new Ajax.Request(...);
var r2 = new Ajax.Request(...);

(function() {
 var data1;
 var data2;

 function handle_r1(data) {
 data1 = data;
 on_both_requests_complete(); 
 };

 function handle_r2(data) {
 data2 = data;
 on_both_requests_complete();
 };

 function on_both_requests_complete() {
 if ( (!data1 || !data2) || processed) {
 return;
 }
 processed = true;

 /* do something */
 };
}();</code></pre>

blocks|key|1660825|text|这就是我要做的。该方法是一种通用方法，它为您提供了更多的灵活性和重用性，并避免了耦合和全局变量的使用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1660826|var+makeEventHandler+=+function(eventMinimum,+callback)+{
++++var+data+=+[];
++++var+eventCount+=+0;
++++var+eventIndex+=+-1;

++++return+function()+{
++++++++//+Create+a+local+copy+to+avoid+issues+with+closure+in+the+inner-most+function
++++++++var+ei+=+%2B%2BeventIndex;
++++++++return+function()+{
++++++++++++//+Convert+arguments+into+an+array
++++++++++++data[ei]+=+Array.prototype.slice.call(arguments);

++++++++++++//+If+the+minimum+event+count+has+not+be+reached,+return
++++++++++++if+(+%2B%2BeventCount+<+eventMinimum++)+{
++++++++++++++++return;
++++++++++++}

++++++++++++//+The+minimum+event+count+has+been+reached,+execute+the+original+callback
++++++++++++callback(data);
++++++++};
++++};
};|code-block|syntax|javascript|1660827|常规用法：|1660828|//+Make+a+multiple+event+handler+that+will+wait+for+3+events
var+multipleEventHandler+=+makeMultipleEventHandler(3,+function(data)+{
++++//+This+is+the+callback+that+gets+called+after+the+third+event
++++console.log(data);
});

multipleEventHandler()(1,2,3);
var+t+=+multipleEventHandler();
setTimeout(function()+{t("some+string");},+1000);
multipleEventHandler()({a:+4,+b:+5,+c:+6});|1660829|回调的输出(由Firebug压缩)：|1660830|+[[1,+2,+3],+["some+string"],+[Object+{+a=4,++more...}]]|1660831|请注意，在最后一个回调中，事件的顺序与调用事件的顺序相同，即使第二个“data”在第三个事件之后执行。|offset|length|style|CODE|1660832|要在Ajax请求的上下文中使用它：|1660833|var+onBothComplete+=+makeMultipleEventHandler(2,+function(data)+{
++++//+Do+something
++++...
});
new+Ajax.Request(url1,+{onComplete:+onBothComplete()});
new+Ajax.Request(url2,+{onComplete:+onBothComplete()});|1660834|编辑:我更新了函数，强制data始终以同步执行的顺序维护异步接收的事件数据(前面的警告不再存在)。|1660835|entityMap^0|0|0|0|0|0|0|Z|4|0|0|0|C|4|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|18|8|@$Q|19|R|1A|S|T]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1B|8|@]|9|@]|A|$]]|$1|W|3|X|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|Y|3|Z|5|6|7|1D|8|@$Q|1E|R|1F|S|T]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|11|$]]

This is how I would do it. The approach is a general one, which gives you more flexibility and reuse, and avoids coupling and the use of globals.

<pre><code>var makeEventHandler = function(eventMinimum, callback) {
 var data = [];
 var eventCount = 0;
 var eventIndex = -1;

 return function() {
 // Create a local copy to avoid issues with closure in the inner-most function
 var ei = ++eventIndex;
 return function() {
 // Convert arguments into an array
 data[ei] = Array.prototype.slice.call(arguments);

 // If the minimum event count has not be reached, return
 if ( ++eventCount &lt; eventMinimum ) {
 return;
 }

 // The minimum event count has been reached, execute the original callback
 callback(data);
 };
 };
};
</code></pre>

General usage:

<pre><code>// Make a multiple event handler that will wait for 3 events
var multipleEventHandler = makeMultipleEventHandler(3, function(data) {
 // This is the callback that gets called after the third event
 console.log(data);
});

multipleEventHandler()(1,2,3);
var t = multipleEventHandler();
setTimeout(function() {t("some string");}, 1000);
multipleEventHandler()({a: 4, b: 5, c: 6});
</code></pre>

Output from callback (condensed by Firebug):

<pre><code> [[1, 2, 3], ["some string"], [Object { a=4, more...}]]
</code></pre>

Notice that the order of <code>data</code> in the final callback is in order of the calling events, even though the second "event" executes after the third.

To use this in context of your Ajax requests:

<pre><code>var onBothComplete = makeMultipleEventHandler(2, function(data) {
 // Do something
 ...
});
new Ajax.Request(url1, {onComplete: onBothComplete()});
new Ajax.Request(url2, {onComplete: onBothComplete()});
</code></pre>

Edit: I've updated the function to force <code>data</code> to always maintain the asynchronously received event data in the synchronously executed order (the previous caveat no longer exists).

blocks|key|1432488|text|基于Justin+Johnson's+response+to+this+question|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1432489|function+sync(delays+/*+Array+of+Functions+*/,+on_complete+/*+Function+*/)+{
++++var+complete_count+=+0;
++++var+results+=+new+Array(delays.length);

++++delays.length.times(function+(i)+{
++++++++function+on_progress(result)+{
++++++++++++results[i]+=+result;
++++++++++++if+(%2B%2Bcomplete_count+==+delays.length)+{
++++++++++++++++on_complete(results);
++++++++++++}
++++++++}
++++++++delays[i](on_progress);
++++});
}|code-block|syntax|javascript|1432490|这假设每个延迟都接受一个参数:一个"on+progress“事件处理程序，该事件处理程序接受一个参数:延迟试图计算的结果。为了完成我原始问题中的示例，您可以这样使用它：|1432491|var+delays+=+[];
delays[0]+=+function+(on_progress)+{
++++new+Ajax.Request(url1,+{onSuccess:+on_progress});
};
delays[1]+=+function+(on_progress)+{
++++new+Ajax.Request(url2,+{onSuccess:+on_progress});
};
function+on_complete(results)+{+alert(results.inspect());+}
sync(delays,+on_complete);|1432492|有一件事我不确定，那就是这是否避免了竞争条件。如果表达式%2B%2Bcomplete_count+==+delays.length总是以原子方式出现，那么这应该是可行的。|1432493|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/2450179/is-there-a-way-to-set-a-handler-function-for-when-a-set-of-events-has-happened/2450613#2450613^0|2|16|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|12|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

Based on <a href="https://stackoverflow.com/questions/2450179/is-there-a-way-to-set-a-handler-function-for-when-a-set-of-events-has-happened/2450613#2450613">Justin Johnson's response to this question</a>:

<pre><code>function sync(delays /* Array of Functions */, on_complete /* Function */) {
 var complete_count = 0;
 var results = new Array(delays.length);

 delays.length.times(function (i) {
 function on_progress(result) {
 results[i] = result;
 if (++complete_count == delays.length) {
 on_complete(results);
 }
 }
 delays[i](on_progress);
 });
}
</code></pre>

This assumes each delay accepts one argument: an "on progress" event handler, which takes one argument: the result that the delay is trying to compute. To complete the example in my original question, you'd use it like so:

<pre><code>var delays = [];
delays[0] = function (on_progress) {
 new Ajax.Request(url1, {onSuccess: on_progress});
};
delays[1] = function (on_progress) {
 new Ajax.Request(url2, {onSuccess: on_progress});
};
function on_complete(results) { alert(results.inspect()); }
sync(delays, on_complete);
</code></pre>

The one thing I'm not sure of is whether this avoids a race condition. If the expression ++complete_count == delays.length always happens atomically, then this should work.

eg I have two concurrent AJAX requests, and I need the result from both to compute a third result. I'm using the Prototype library, so it might look something like this:

<pre><code>var r1 = new Ajax.Request(url1, ...);
var r2 = new Ajax.Request(url2, ...);

function on_both_requests_complete(resp1, resp2) {
 ...
}
</code></pre>

One way would be to use polling, but I'm thinking there must be a better way.

Update: An acceptable solution must be free of race conditions.

Is there a way to set a handler function for when a set of events has happened?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

例如，我有两个并发的AJAX请求，我需要这两个请求的结果来计算第三个结果。我使用的是Prototype库，所以它可能看起来像这样：var r1 = new Ajax.Request(url1, ...);var r2 = new Ajax.Request(url2, ...);function on_both_requ...

问当一组事件发生时，有没有办法设置一个处理函数？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问当一组事件发生时，有没有办法设置一个处理函数？EN