Jquery File Download Event

jQuery's event system normalizes the event object according to W3C standards. The event object is guaranteed to be passed to the event handler. Most properties from the original event are copied over and normalized to the new event object.

This was also the recommended way to replicate the behavior of the deprecated .live() event. Which is important to me since a lot of my sites dynamically add/remove widgets all the time. The above doesn't behave exactly like .live() though, since only elements added to the already existing container '.my-widget' will get the behavior. If I dynamically add another block of html after that code has ran, those elements will not get the events bound to them. Like this:

Download 🔥 https://urlin.us/2y3Ikk 🔥

Which seems to meet all my goals. (Yes it's slower in IE for some reason, no idea why?)It's fast because only a single event is tied to a singular element and the secondary selector is only evaluated when the event occurs (please correct me if this is wrong here). The namespace is awesome since it makes it easier to toggle the event listener.

So I'm starting to think that jQuery events should always be bound to $(document).

Is there any reason why you would not want to do this?

Could this be considered a best practice? If not, why?

First off, event delegation does not always make your code faster. In some cases, it's is advantageous and in some cases not. You should use event delegation when you actually need event delegation and when you benefit from it. Otherwise, you should bind event handlers directly to the objects where the event happens as this will generally be more efficient.

Second off, you should NOT bind all delegated events at the document level. This is exactly why .live() was deprecated because this is very inefficient when you have lots of events bound this way. For delegated event handling it is MUCH more efficient to bind them to the closest parent that is not dynamic.

Third off, not all events work or all problems can be solved with delegation. For example, if you want to intercept key events on an input control and block invalid keys from being entered into the input control, you cannot do that with delegated event handling because by the time the event bubbles up to the delegated handler, it has already been processed by the input control and it's too late to influence that behavior.

It installs a generic jQuery event handler on the #myParent object. When a click event bubbles up to this delegated event handler, jQuery has to go through the list of delegated event handlers attached to this object and see if the originating element for the event matches any of the selectors in the delegated event handlers.

Because selectors can be fairly involved, this means that jQuery has to parse each selector and then compare it to the characteristics of the original event target to see if it matches each selector. This is not a cheap operation. It's no big deal if there is only one of them, but if you put all your selectors on the document object and there were hundreds of selectors to compare to every single bubbled event, this can seriously start to hobble event handling performance.

For this reason, you want to set up your delegated event handlers so a delegated event handler is as close to the target object as practical. This means that fewer events will bubble through each delegated event handler, thus improving the performance. Putting all delegated events on the document object is the worst possible performance because all bubbled events have to go through all delegated event handlers and get evaluated against all possible delegated event selectors. This is exactly why .live() is deprecated because this is what .live() did and it proved to be very inefficient.

PS: Even for dynamic contents you don't have to use event delegation method if you are bind the handler after the contents get inserted into DOM. (If the dynamic content be added not frequently removed/re-added)

First off, event delegation does not always make your code faster. Insome cases, it's is advantageous and in some cases not. You should useevent delegation when you actually need event delegation and when youbenefit from it. Otherwise, you should bind event handlers directly tothe objects where the event happens as this will generally be moreefficient.

While it's true that performance might be slightly better if you are only going to register an event for a single element, I believe it doesn't outweigh the scalability benefits that delegation brings. I also believe browsers are (going to be) handling this more and more efficiently, although I have no proof of this. In my opinion, event delegation is the way to go!

Second off, you should NOT bind all delegated events at the documentlevel. This is exactly why .live() was deprecated because this is veryinefficient when you have lots of events bound this way. For delegatedevent handling it is MUCH more efficient to bind them to the closestparent that is not dynamic.

I kind of agree on this. If you are 100% sure that an event will only happen inside a container, it makes sense to bind the event to this container, but I would still argue against binding events to the triggering element directly.

Third off, not all events work or all problems can be solved withdelegation. For example, if you want to intercept key events on aninput control and block invalid keys from being entered into the inputcontrol, you cannot do that with delegated event handling because bythe time the event bubbles up to the delegated handler, it has alreadybeen processed by the input control and it's too late to influencethat behavior.

When the objects you are capturing events on are dynamicallycreated/removed and you still want to capture events on them withouthaving to explicitly rebind event handlers every time you create a newone. When you have lots of objects that all want the exact same eventhandler (where lots is at least hundreds). In this case, it may bemore efficient at setup time to bind one delegated event handlerrather than hundreds or more direct event handlers. Note, delegatedevent handling is always less efficient at run-time than direct eventhandlers.

When you're trying to capture (at a higher level in your document)events that occur on any element in the document. When your design isexplicitly using event bubbling and stopPropagation() to solve someproblem or feature in your page. To understand this a little more, oneneeds to understand how jQuery delegated event handlers work. When youcall something like this:

$("#myParent").on('click', 'button.actionButton', myFn); It installs ageneric jQuery event handler on the #myParent object. When a clickevent bubbles up to this delegated event handler, jQuery has to gothrough the list of delegated event handlers attached to this objectand see if the originating element for the event matches any of theselectors in the delegated event handlers.

Because selectors can be fairly involved, this means that jQuery hasto parse each selector and then compare it to the characteristics ofthe original event target to see if it matches each selector. This isnot a cheap operation. It's no big deal if there is only one of them,but if you put all your selectors on the document object and therewere hundreds of selectors to compare to every single bubbled event,this can seriously start to hobble event handling performance.

For this reason, you want to set up your delegated event handlers so adelegated event handler is as close to the target object as practical.This means that fewer events will bubble through each delegated eventhandler, thus improving the performance. Putting all delegated eventson the document object is the worst possible performance because allbubbled events have to go through all delegated event handlers and getevaluated against all possible delegated event selectors. This isexactly why .live() is deprecated because this is what .live() did andit proved to be very inefficient.

I'm assuming you meant the first line of code in your question. It basically defines bsTransitionEnd as an alias for the transition end event (the transition end event may vary from browser to browser - that is what the function transitionEnd() does : determine the proper transition end event for the browser. I've used webkitTransitionEnd here on, but it could be something else depending on the browser)

Why would you or another library do that? The webkitTransitionEnd is a standard event, so let's say you decide to add a transition end animation to a bootstrap dialog - you'd probably do $('myBootstrapDialog').on('webkitTransitionEnd', your handler) and later on you decide to remove the handler you should be going $('myBootstrapDialog').off('webkitTransitionEnd', your handler), but you miscode it as $('myBootstrapDialog').off('webkitTransitionEnd') - this removes all transition end events :-(.

The bindType and delegateType basically state that bsTransitionEnd is an alias for transition events attached directly, and ones that are delegated (bubbles). The handle is basically a filter function - all the triggered events basically go through this before the attached Bootstrap event handlers are called (if at all they are)

I'm sure you'd know most of it already - it's a way to hook into jQuery's event handling mechanism allowing you do large scale magic like do X on every attached click event on the page (imagine doing that one by one, at each and every place you've attached an onclick event), define your own events (with all the bubbly goodness and all which comes with it), hook in and spoof events by modifying the event object, etc.

(paraphrasing) - let's say you do an AJAX submit and want to disable all clicks on the page (you probably don't want the user clicking on and navigating off to some other page via a menu, or changing a checkbox, etc.) and $.event.special.click should help you (of course it might be just easier / traditional to just overlay a transparent / partially transparent div with a Submitting... animation or something or not doing anything - after all, most users wait around to make sure a submit was successful, at least the normal ones :-)) 2351a5e196