Home > jQuery > How to Bind Dynamically Added Elements with jQuery?

How to Bind Dynamically Added Elements with jQuery?

Have you ever encountered a scenario where you dynamically add elements to your webpage, but find that your jQuery events don’t work on them? It’s a common issue that many developers face.

But fear not, because, in this blog post, we’ll walk through how to effectively bind events to dynamically added elements using jQuery and tips for event handling.

Understanding the Problem

When working with dynamic elements in web development, binding events to those elements can be a bit challenging. This is because these elements do not exist in the DOM at the time when the JavaScript code is executed. However, using jQuery, we can easily bind dynamically added elements by taking advantage of its event delegation feature.

Let’s understand why this issue occurs. When you bind an event to an element using jQuery’s .on() method, it attaches the event handler to the existing elements matching the selector at the time the code is executed. However, if you add new elements dynamically to the DOM after the initial page load, those elements won’t have the event handlers attached to them automatically.

What is Event Delegation?

Event delegation is a technique used in JavaScript whereby an event listener is attached to a parent element instead of attaching it directly to the target child element(s).

When an event occurs, the event bubbles up through the DOM tree, allowing the parent element to capture the event and take appropriate action based on the target element that triggered the event.

Why Use Event Delegation?

Using event delegation has several advantages, including:

  • Improved performance: By attaching an event listener to a parent element rather than individual child elements, fewer event listeners need to be created and managed, resulting in better performance.
  • Handling dynamic content: Since event delegation relies on capturing events as they bubble up the DOM tree, it works well with dynamic content. As new elements are added to the page, there’s no need to attach additional event listeners; the existing parent element will continue to handle events from all matching descendant elements.

Binding Dynamic Elements with jQuery

To bind dynamically added elements with jQuery, we can use the on() method along with event delegation. See the following example.

Solution 1: Using Event Delegation

One of the most common solutions to this problem is using event delegation. Event delegation allows you to attach an event handler to a parent element that will fire for all descendants matching a selector, even if they are added to the DOM dynamically.


$(document).on('click', '.dynamic-element', function() {
    // Your event handler code here

In this syntax, $(document) is the parent element that remains present in the DOM since page load, and .dynamic-element is the selector for the dynamically added elements. Whenever a click event occurs on an element matching .dynamic-element, the event handler will execute.


Let’s see the example of event delegation using the .on() method.

$(document).ready(function() {
    // Attach click event handler to parent element (<ul>)
    $('#parent').on('click', 'li', function() {
        console.log("You clicked on list item:", $(this).text());

	// Add some dynamic <li> elements to the <ul>
	$('#parent').append('<li>Dynamic List Item 1</li><li>Dynamic List Item 2</li>');

In this example, we first select the parent element (in this case, a <ul> element) and attach a click event handler using the on() method. We pass two arguments to on() – the name of the event we want to listen for (‘click’), followed by a selector string that matches our desired child elements ('li').

By passing a second argument to on(), we tell jQuery to delegate the event handling to the parent element, so that any clicks on matching child elements will trigger the specified callback function.

We then add some dynamic <li> elements to the <ul>. Because we’ve already set up event delegation, clicking on any of these new elements will still trigger the callback function defined earlier.

Note that in cases where the parent element itself may be replaced dynamically, it’s best to attach the event listener to the nearest static ancestor element instead. For instance, if our <ul> were being generated dynamically, we could instead attach the event listener to the document body or another enclosing container element.

Solution 2: Binding Events After Element Creation

Another approach is to bind the event handler to the dynamically added element immediately after it is created. This ensures that the event handler is attached as soon as the element is added to the DOM.

var newElement = $('<button>').text('Click me').addClass('dynamic-element');

newElement.on('click', function() {
    // Your event handler code here


In this example, we create a new button element, bind a click event handler to it, and then append it to a container element with the id #container. Now, whenever this button is clicked, the event handler will execute.

Best Practices

When working with dynamic elements and jQuery’s on() method, follow these guidelines to ensure optimal performance and maintainability:

  • Always prefer delegated events over live ones since they tend to be faster and more resource-efficient.
  • Whenever possible, attach event listeners to the closest available parent element containing the target elements to minimize unnecessary propagation delays.
  • Leverage namespacing to organize and manage complex sets of events more effectively.

Additional Tips and Tricks

  • Using the off() Method: If you ever need to remove a dynamically bound event listener, you can use jQuery’s off() method. Simply call off() on the same parent element and specify the relevant event type and optional selector string to unbind the listener.
  • Multiple Events: The on() method supports multiple events separated by spaces within the first argument. For instance, to listen for both ‘click‘ and ‘mouseenter‘ events, simply call $('#element').on('click mouseenter', ...);.
  • Data Parameters: Passing data parameters to the on() method allows you to associate custom data values with the listener. These values can later be accessed via the event.data property inside the callback function.

Example Code Snippet

The following code example of the usage of the off() method to remove the event listener.

// Example usage of off() method to remove event listener
$('.button').on('click', { message: 'Button was clicked!' }, function(event) {

See the following example of the usage of multiple events with data parameters.

// Example usage of multiple events with data parameter
    click: { message: 'Box was clicked!' },
    mouseenter: { message: 'Mouse entered box area.' }
}, function(event) {
    alert(event.type + ": " + event.data.message);


With jQuery’s powerful on() method and event delegation feature, binding dynamically added elements becomes much easier and more efficient. We can improve performance and simplify dynamic content management by attaching event handlers to parent elements instead of individual children. Whether adding buttons, form inputs, or other interactive elements, event delegation is a valuable technique to keep in your toolkit.

Binding events to dynamically added elements in jQuery doesn’t have to be a headache. By understanding the problem and using techniques like event delegation or binding events after element creation, you can ensure that your events work seamlessly even on dynamically added content.


What does it mean to bind dynamically added elements with jQuery?

Binding dynamically added elements refers to associating actions or functions to newly inserted HTML components. With jQuery, this can be achieved seamlessly using the on() method, ensuring responsiveness even upon changing DOM structures.

How does event delegation help in binding dynamically added elements?

Event delegation enables assigning a single event listener to a parent element, catching subsequent events originating from its nested child elements, regardless of creation timing – during runtime or beforehand. This mechanism enhances efficiency and facilitates handling dynamic modifications effortlessly.

Why is it recommended to use the nearest possible static ancestor as the parent element in event delegation?

Utilizing the closest feasible static parent reduces unnecessary traversals throughout the DOM tree, thereby improving overall performance. Selecting higher-level containers, like document or body, might result in redundant operations and potential conflicts among registered event listeners.

Can I send additional information to the event handler while employing event delegation?

Absolutely! Just incorporate supplementary arguments after the selector string in the on() method. Those arguments will subsequently become accessible within the event handler, offering extended capabilities tailored to your needs.

Are there any guidelines for the optimal utilization of event delegation with jQuery?

Adhere to best practices such as crafting explicit selectors, caching frequently utilized jQuery objects, organizing related occurrences utilizing namespaces, and preferring class designators over unique identifiers. Such strategies promote maintainability, readability, and improved system performance.

Photo of author

About Aman Mehra

Hey there! I'm Aman Mehra, a full-stack developer with over six years of hands-on experience in the industry. I've dedicated myself to mastering the ins and outs of PHP, WordPress, ReactJS, NodeJS, and AWS, so you can trust me to handle your web development needs with expertise and finesse. In 2021, I decided to share my knowledge and insights with the world by starting this blog. It's been an incredible journey so far, and I've had the opportunity to learn and grow alongside my readers. Whether you're a seasoned developer or just dipping your toes into the world of web development, I'm here to provide valuable content and solutions to help you succeed. So, stick around, explore the blog, and feel free to reach out if you have any questions or suggestions. Together, let's navigate the exciting world of web development!

Leave a Comment