Is there a JavaScript / jQuery DOM change listener?

Several years later, there is now officially a better solution. DOM4 Mutation Observers are the replacement for deprecated DOM3 mutation events. They are currently implemented in modern browsers as MutationObserver (or as the vendor-prefixed WebKitMutationObserver in old versions of Chrome):

MutationObserver = window.MutationObserver || window.WebKitMutationObserver;

var observer = new MutationObserver(function(mutations, observer) {
    // fired when a mutation occurs
    console.log(mutations, observer);
    // ...
});

// define what element should be observed by the observer
// and what types of mutations trigger the callback
observer.observe(document, {
  subtree: true,
  attributes: true
  //...
});

This example listens for DOM changes on document and its entire subtree, and it will fire on changes to element attributes as well as structural changes. The draft spec has a full list of valid mutation listener properties:

childList* Set to true if mutations to target’s children are to be observed.
childList* Set to true if mutations to target’s children are to be observed.
childList* Set to true if mutations to target’s children are to be observed.
childList* Set to true if mutations to target’s children are to be observed.
childList* Set to true if mutations to target’s children are to be observed.
childList* Set to true if mutations to target’s children are to be observed.
childList* Set to true if mutations to target’s children are to be observed.

This answer is now deprecated. See the answer by apsillers.

Since this is for a Chrome extension, you might as well use the standard DOM event - DOMSubtreeModified. See the support for this event across browsers. It has been supported in Chrome since 1.0.

$("#someDiv").bind("DOMSubtreeModified", function() {
    alert("tree changed");
});

See a working example here.

nother approach depending on how you are changing the div. If you are using JQuery to change a div’s contents with its html() method, you can extend that method and call a registration function each time you put html into a div.

(function( $, oldHtmlMethod ){
    // Override the core html method in the jQuery object.
    $.fn.html = function(){
        // Execute the original HTML method using the
        // augmented arguments collection.

        var results = oldHtmlMethod.apply( this, arguments );
        com.invisibility.elements.findAndRegisterElements(this);
        return results;

    };
})( jQuery, jQuery.fn.html );

We just intercept the calls to html(), call a registration function with this, which in the context refers to the target element getting new content, then we pass on the call to the original jquery.html() function. Remember to return the results of the original html() method, because JQuery expects it for method chaining.

For more info on method overriding and extension, check out http://www.bennadel.com/blog/2009-Using-Self-Executing-Function-Arguments-To-Override-Core-jQuery-Methods.htm, which is where I cribbed the closure function. Also check out the plugins tutorial at JQuery’s site

In addition to the “raw” tools provided by [MutationObserver](https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver "MutationObserver") API, there exist “convenience” libraries to work with DOM mutations.

Consider: MutationObserver represents each DOM change in terms of subtrees. So if you’re, for instance, waiting for a certain element to be inserted, it may be deep inside the children of mutations.mutation[i].addedNodes[j].

Another problem is when your own code, in reaction to mutations, changes DOM - you often want to filter it out.

A good convenience library that solves such problems is [mutation-summary](https://github.com/rafaelw/mutation-summary "mutation-summary") (disclaimer: I’m not the author, just a satisfied user), which enables you to specify queries of what you’re interested in, and get exactly that.

Basic usage example from the docs:

var observer = new MutationSummary({
  callback: updateWidgets,
  queries: [{
    element: '[data-widget]'
  }]
});

function updateWidgets(summaries) {
  var widgetSummary = summaries[0];
  widgetSummary.added.forEach(buildNewWidget);
  widgetSummary.removed.forEach(cleanupExistingWidget);
}

Many sites use AJAX to add/show/change content dynamically. Sometimes it’s used instead of in-site navigation, so current URL is changed programmatically and content scripts aren’t automatically executed by browser in this case since the page isn’t fetched from remote server entirely.

Usual JS methods of detecting page changes available in a content script.

• MutationObserver (docs) to literally detect DOM changes:
  How to change the HTML content as it’s loading on the pagePerformance of MutationObserver to detect nodes in entire DOM.* Event listener for sites that signal content change by sending a DOM event:
• pjax:end on document used by many pjax-based sites e.g. GitHub,
  see How to run jQuery before and after a pjax load?* message on window used by e.g. Google search in Chrome browser,
  see Chrome extension detect Google search refresh* spfdone on document used by Youtube,
  see How to detect page navigation on Youtube and modify HTML before page is rendered?* Periodic checking of DOM via setInterval:
• Obviously this will work only in cases when you wait for a specific element identified by its id/selector to appear, and it won’t let you universally detect new dynamically added content unless you invent some kind of fingerprinting the existing contents.
• Cloaking History API inside an injected DOM script:

document.head.appendChild(document.createElement('script')).text = '(' +
    function() {
        // injected DOM script is not a content script anymore, 
        // it can modify objects and functions of the page
        var _pushState = history.pushState;
        history.pushState = function(state, title, url) {
            _pushState.call(this, state, title, url);
            window.dispatchEvent(new CustomEvent('state-changed', {detail: state}));
        };
        // repeat the above for replaceState too
    } + ')(); this.remove();'; // remove the DOM script element

// And here content script listens to our DOM script custom events
window.addEventListener('state-changed', function(e) {
    console.log('History state changed', e.detail, location.hash);
    doSomething();
});

• MutationObserver (docs) to literally detect DOM changes:
  How to change the HTML content as it’s loading on the pagePerformance of MutationObserver to detect nodes in entire DOM.* Event listener for sites that signal content change by sending a DOM event:
• pjax:end on document used by many pjax-based sites e.g. GitHub,
  see How to run jQuery before and after a pjax load?* message on window used by e.g. Google search in Chrome browser,
  see Chrome extension detect Google search refresh* spfdone on document used by Youtube,
  see How to detect page navigation on Youtube and modify HTML before page is rendered?* Periodic checking of DOM via setInterval:
• Obviously this will work only in cases when you wait for a specific element identified by its id/selector to appear, and it won’t let you universally detect new dynamically added content unless you invent some kind of fingerprinting the existing contents.
• Cloaking History API inside an injected DOM script:

window.addEventListener('hashchange', function(e) {
    console.log('URL hash changed', e);
    doSomething();
});
window.addEventListener('popstate', function(e) {
    console.log('State changed', e);
    doSomething();
});

• MutationObserver (docs) to literally detect DOM changes:
  How to change the HTML content as it’s loading on the pagePerformance of MutationObserver to detect nodes in entire DOM.* Event listener for sites that signal content change by sending a DOM event:
• pjax:end on document used by many pjax-based sites e.g. GitHub,
  see How to run jQuery before and after a pjax load?* message on window used by e.g. Google search in Chrome browser,
  see Chrome extension detect Google search refresh* spfdone on document used by Youtube,
  see How to detect page navigation on Youtube and modify HTML before page is rendered?* Periodic checking of DOM via setInterval:
• Obviously this will work only in cases when you wait for a specific element identified by its id/selector to appear, and it won’t let you universally detect new dynamically added content unless you invent some kind of fingerprinting the existing contents.
• Cloaking History API inside an injected DOM script:

Extensions-specific: detect URL changes in a background / event page.

There are advanced API to work with navigation: webNavigation, webRequest, but we’ll use simple chrome.tabs.onUpdated event listener that sends a message to the content script:

• MutationObserver (docs) to literally detect DOM changes:
  How to change the HTML content as it’s loading on the pagePerformance of MutationObserver to detect nodes in entire DOM.* Event listener for sites that signal content change by sending a DOM event:
• pjax:end on document used by many pjax-based sites e.g. GitHub,
  see How to run jQuery before and after a pjax load?* message on window used by e.g. Google search in Chrome browser,
  see Chrome extension detect Google search refresh* spfdone on document used by Youtube,
  see How to detect page navigation on Youtube and modify HTML before page is rendered?* Periodic checking of DOM via setInterval:
• Obviously this will work only in cases when you wait for a specific element identified by its id/selector to appear, and it won’t let you universally detect new dynamically added content unless you invent some kind of fingerprinting the existing contents.
• Cloaking History API inside an injected DOM script:

var rxLookfor = /^https?:\/\/(www\.)?google\.(com|\w\w(\.\w\w)?)\/.*?[?#&]q=/;
chrome.tabs.onUpdated.addListener(function(tabId, changeInfo, tab) {
    if (rxLookfor.test(changeInfo.url)) {
        chrome.tabs.sendMessage(tabId, 'url-update');
    }
});

• MutationObserver (docs) to literally detect DOM changes:
  How to change the HTML content as it’s loading on the pagePerformance of MutationObserver to detect nodes in entire DOM.* Event listener for sites that signal content change by sending a DOM event:
• pjax:end on document used by many pjax-based sites e.g. GitHub,
  see How to run jQuery before and after a pjax load?* message on window used by e.g. Google search in Chrome browser,
  see Chrome extension detect Google search refresh* spfdone on document used by Youtube,
  see How to detect page navigation on Youtube and modify HTML before page is rendered?* Periodic checking of DOM via setInterval:
• Obviously this will work only in cases when you wait for a specific element identified by its id/selector to appear, and it won’t let you universally detect new dynamically added content unless you invent some kind of fingerprinting the existing contents.
• Cloaking History API inside an injected DOM script:

chrome.runtime.onMessage.addListener(function(msg, sender, sendResponse) {
    if (msg === 'url-update') {
        doSomething();
    }
});