Attach event to dynamic elements in JavaScript

There is a workaround by capturing clicks on document.body and then checking event target.

document.body.addEventListener( 'click', function ( event ) { if( event.target.id == 'btnSubmit' ) { someFunc(); }; } ); 

The DOM:

const iAmAString = '<li>hi</li>';

const iAmAnElement = document.createElement('li');

Elements have events. Strings just say things. Even if they have HTML in them.

What I like to do is create elements like this:

const myString = '<h1>hi there</h1>'; document.body.insertAdjacentHTML('beforeend', myString); 

I am not sure if you can add an event though...like where would I do that? I don't know.

You can definitely do this:

const button = document.getElementById('btnSubmit'); button.addEventListener('click', function () { // Create the element const li = document.createElement('li'); // Add the event listener li.onclick = function () { console.log('Now that you have an element reference you can add a click event like this!') } // Add the element to the DOM document.querySelector('ul').appendChild(li); }); 

So this thing well call the DOM is a big thing. It has all these interesting functions. I like to type window in the Chrome console and explore. There are so many cool things in there!

The point is that a "string" is different than an "object." Objects are fun. Strings are boring.

You must attach the event after insert elements, like that you don't attach a global event on your document but a specific event on the inserted elements.

e.g.

document.getElementById('form').addEventListener('submit', function(e) { e.preventDefault(); var name = document.getElementById('txtName').value; var idElement = 'btnPrepend'; var html = ` <ul> <li>${name}</li> </ul> <input type="button" value="prepend" id="${idElement}" /> `; /* Insert the html into your DOM */ insertHTML('form', html); /* Add an event listener after insert html */ addEvent(idElement); }); const insertHTML = (tag = 'form', html, position = 'afterend', index = 0) => { document.getElementsByTagName(tag)[index].insertAdjacentHTML(position, html); } const addEvent = (id, event = 'click') => { document.getElementById(id).addEventListener(event, function() { insertHTML('ul', '<li>Prepending data</li>', 'afterbegin') }); }

<form id="form"> <div> <label for="txtName">Name</label> <input id="txtName" name="txtName" type="text" /> </div> <input type="submit" value="submit" /> </form>

Here's a reusable function that takes advantage of element.matches:

function delegate_event(event_type, ancestor_element, target_element_selector, listener_function) { ancestor_element.addEventListener(event_type, function(event) { if (event.target && event.target.matches && event.target.matches(target_element_selector)) { (listener_function)(event); } }); } 

Here's how you would use it for a click event:

delegate_event('click', document, '.alert-button', your_function_here); 

You can do something similar to this:

// Get the parent to attatch the element into var parent = document.getElementsByTagName("ul")[0]; // Create element with random id var element = document.createElement("li"); element.id = "li-"+Math.floor(Math.random()*9999); // Add event listener element.addEventListener("click", EVENT_FN); // Add to parent parent.appendChild(element); 

I have created a small library to help with this: Library source on GitHub

<script src="dynamicListener.min.js"></script> <script> // Any `li` or element with class `.myClass` will trigger the callback, // even elements created dynamically after the event listener was created. addDynamicEventListener(document.body, 'click', '.myClass, li', function (e) { console.log('Clicked', e.target.innerText); }); </script> 

The functionality is similar to jQuery.on().

The library uses the Element.matches() method to test the target element against the given selector. When an event is triggered the callback is only called if the target element matches the selector given.

var __ = function(){ this.context = []; var self = this; this.selector = function( _elem, _sel ){ return _elem.querySelectorAll( _sel ); } this.on = function( _event, _element, _function ){ this.context = self.selector( document, _element ); document.addEventListener( _event, function(e){ var elem = e.target; while ( elem != null ) { if( "#"+elem.id == _element || self.isClass( elem, _element ) || self.elemEqal( elem ) ){ _function( e, elem ); } elem = elem.parentElement; } }, false ); }; this.isClass = function( _elem, _class ){ var names = _elem.className.trim().split(" "); for( this.it = 0; this.it < names.length; this.it++ ){ names[this.it] = "."+names[this.it]; } return names.indexOf( _class ) != -1 ? true : false; }; this.elemEqal = function( _elem ){ var flg = false; for( this.it = 0; this.it < this.context.length; this.it++ ){ if( this.context[this.it] === _elem && !flg ){ flg = true; } } return flg; }; } function _( _sel_string ){ var new_selc = new __( _sel_string ); return new_selc; } 

Now you can register event like,

_( document ).on( "click", "#brnPrepend", function( _event, _element ){ console.log( _event ); console.log( _element ); // Todo }); 

Browser Support

chrome - 4.0, Edge - 9.0, Firefox - 3.5 Safari - 3.2, Opera - 10.0 and above

I have found the solution posted by jillykate works, but only if the target element is the most nested. If this is not the case, this can be rectified by iterating over the parents, i.e.

function on_window_click(event) { let e = event.target; while (e !== null) { // --- Handle clicks here, e.g. --- if (e.getAttribute(`data-say_hello`)) { console.log("Hello, world!"); } e = e.parentElement; } } window.addEventListener("click", on_window_click); 

Also note we can handle events by any attribute, or attach our listener at any level. The code above uses a custom attribute and window. I doubt there is any pragmatic difference between the various methods.

I know that the topic is too old but I gave myself some minutes to create a very useful code that works fine and very easy using pure JAVASCRIPT. Here is the code with a simple example:

String.prototype.addEventListener=function(eventHandler, functionToDo){ let selector=this; document.body.addEventListener(eventHandler, function(e){ e=(e||window.event); e.preventDefault(); const path=e.path; path.forEach(function(elem){ const selectorsArray=document.querySelectorAll(selector); selectorsArray.forEach(function(slt){ if(slt==elem){ if(typeof functionToDo=="function") functionToDo(el=slt, e=e); } }); }); }); } // And here is how we can use it actually ! "input[type='number']".addEventListener("click", function(element, e){	console.log( e ); // Console log the value of the current number input });

<input type="number" value="25"> <br> <input type="number" value="15"> <br><br> <button onclick="addDynamicInput()">Add a Dynamic Input</button> <script type="text/javascript"> function addDynamicInput(){ const inpt=document.createElement("input"); inpt.type="number"; inpt.value=Math.floor(Math.random()*30+1); document.body.prepend(inpt); } </script>

I've made a simple function for this.

The _case function allows you to not only get the target, but also get the parent element where you bind the event on.

The callback function returns the event which holds the target (evt.target) and the parent element matching the selector (this). Here you can do the stuff you need after the element is clicked.

I've not yet decided which is better, the if-else or the switch

var _case = function(evt, selector, cb) { var _this = evt.target.closest(selector); if (_this && _this.nodeType) { cb.call(_this, evt); return true; } else { return false; } } document.getElementById('ifelse').addEventListener('click', function(evt) { if (_case(evt, '.parent1', function(evt) { console.log('1: ', this, evt.target); })) return false; if (_case(evt, '.parent2', function(evt) { console.log('2: ', this, evt.target); })) return false; console.log('ifelse: ', this); }) document.getElementById('switch').addEventListener('click', function(evt) { switch (true) { case _case(evt, '.parent3', function(evt) { console.log('3: ', this, evt.target); }): break; case _case(evt, '.parent4', function(evt) { console.log('4: ', this, evt.target); }): break; default: console.log('switch: ', this); break; } })

#ifelse { background: red; height: 100px; } #switch { background: yellow; height: 100px; }

<div id="ifelse"> <div class="parent1"> <div class="child1">Click me 1!</div> </div> <div class="parent2"> <div class="child2">Click me 2!</div> </div> </div> <div id="switch"> <div class="parent3"> <div class="child3">Click me 3!</div> </div> <div class="parent4"> <div class="child4">Click me 4!</div> </div> </div>

Hope it helps!

I like @Pikamander2 solution because it does not involve an event binding on document, or body (you will wake up someday with each click on document triggering dozens of event handlers...).

Here is an improvement of Pikamander2 solution.

If the dynamically added child is itself a dom element with children (ex: <button><u>label</u></button>, the e.target may return the <u> element. So you may use :

function delegateEvent( eventType, ancestorElem, childSelector, eventHandler ) { // Cancel if ancestorElem does not exists if( ! ancestorElem || ( typeof ancestorElem === 'string' && ! ( ancestorElem = document.querySelector( ancestorElem ) ) ) ) { return } ancestorElem.addEventListener( eventType, e => { if( e.target && e.target.closest && e.target.closest( childSelector ) ) { ( eventHandler )( e ) } } ) } 

I also added a snippet to make the function accept a selector for ancestor instead of an element only

First of all add the dynamic class to the dynamically created inputboxes

var ele = document.createElement('textarea'); ele.className = "css-class-name"; // set the CSS class ele.setAttribute('type', 'textarea'); ele.setAttribute('value', ''); ele.setAttribute("id", `row${rcount}_${c}`); 

and then do the following...

const btns = document.querySelectorAll('.css-class-name'); for (let i = 0; i < btns.length; i++) { btns[i].addEventListener('keyup', function (e) { console.log(e.target.id); let textValues = $(`#${e.target.id}`).val() console.log("=============values =====", textValues) //on key press take id and set value of that id what i am inputting. }); } 

This is an old question - but I spent a lot of hours with this problem. Maybe my solution helps someone.

Context: Attaching event listeners to elements dynamically created from an Ajax response. Making an selectable by click, or by keyboard navigation: In both cases, the same function is called.

The first line worked, the second line did not allow me to click on the item:

item.addEventListener("mouseover", this.mouseOver.bind(this) ) item.addEventListener("click", this.clickedItem.bind(this) ) 

However, this continued to work:

item.click(); 

(Suggesting the click event was added, and calling the function - but the mouse was not dispatching a click event)

The solution was to change :

item.addEventListener("click", this.clickedItem.bind(this) ) 

to this:

item.addEventListener("mousedown", this.clickedItem.bind(this) ) 

I saw on old SO message that suggested that <div>s do not respond to mouse click events - but all the documentation I read contradicted that.

So, I don't know what's going on here.