Controlling the order that event handlers / listeners are executed in

Once again the IE Monster has hit me with an odd problem.

I'm writing some changes into an asp.net site I inherited a while back. One of the problems is that in some pages there are several controls that add Javascript functions as handlers to the onload event (using YUI if that matters). Some of those event handlers assume certain other functions have been executed.

This is well and good in Firefox and IE7 as the handlers seem to execute in order of registration. IE8 on the other hand does this backwards.

I could go with some kind of double-checking approach but given the controls are present in several pages I feel that'd create even more dependencies. So I've started cooking up my own queue class that I push the functions to and can control their execution order. Then I'll register an onload handler that instructs the queue to execute in my preferred order.

I'm part way through that and have started wondering 2 things:

1. Am I going OTT?
2. Am I reinventing the wheel?

Anyone have any insights? Any clean solutions that allow me to easily enf开发者_运维问答orce execution order?

---

I could not find any Standard that would define the call-order of events. This is not an issue this is pure anarchy :D

Also there's hundreds of independent implementations of this pattern, so it is unlikely that they would behave coherently anytime soon.

So yes you're off on your own.

The cleanest and most compatible approach I have, involves registering just one event-handler :D That way the native order becomes irrelevant.

Now the trick is to add your own predictable event-management on top of that - using a library, extending with nodeJS's version for example, depending on your requirements.

Note that JS gives you the freedom to just override the prototype-derived functions, so another possibility is something like this:

function eventify(element){
  element._event = {}
  element.on = element.addListener = function(evt,fn){ ... }
  element.off = element.removeListener = function(evt,fn){ ... }
  element.emit function(evt,args...){ ... do it the right way ... }
}

So maybe you are a little off track in considering queues and locking-mechanisms :)