O'Reilly

afterscriptexecute Event

By on  

Fellow Mozillian Daniel Buchner, curator of the X-Tag project and clever developer who showed us how to detect dom node insertions using CSS animations, recently showed me a new feature JavaScript feature I'd never heard of:  the SCRIPT element's afterscriptexecute event.  This event, when detected within the document, provides developers insight as to when specific SCRIPT elements are executed.

The following snippet listens for script executions on the page and logs the specifc SCRIPT element to the console after executed:

<script id="my_script" type="text/javascript">
document.addEventListener('afterscriptexecute', function(e){
  console.log('Script executed: ', e.target);
}, false);
</script>

<script type="text/javascript">console.log('foo')</script>

<script type="text/javascript">console.log('bar')</script>


This technique will be incredibly useful for debugging complex JavaScript applications, allowing developers to know exactly which script had just been injected and executed.

Daniel has a knack for finding useful new techniques and this tip will be helpful down the road.  Unfortunately only Firefox has implemented this event but I look forward to WebKit support soonish.  Can you think of how you'd use this event?

Treehouse Learning

Recent Features

  • Write Better JavaScript with Promises

    You've probably heard the talk around the water cooler about how promises are the future. All of the cool kids are using them, but you don't see what makes them so special. Can't you just use a callback? What's the big deal? In this article, we'll...

  • Vibration API

    Many of the new APIs provided to us by browser vendors are more targeted toward the mobile user than the desktop user.  One of those simple APIs the Vibration API.  The Vibration API allows developers to direct the device, using JavaScript, to vibrate in...

Incredible Demos

  • Six Degrees of Kevin Bacon Using MooTools 1.2

    As you can probably tell, I try to mix some fun in with my MooTools madness but I also try to make my examples as practical as possible. Well...this may not be one of those times. I love movies and useless movie trivia so naturally I'm...

  • Introducing LazyLoad 2.0

    While improvements in browsers means more cool APIs for us to play with, it also means we need to maintain existing code.  With Firefox 4's release came news that my MooTools LazyLoad plugin was not intercepting image loading -- the images were loading regardless of...

Discussion

  1. It would appear from reading the spec (step 9 of http://www.w3.org/html/wg/drafts/html/master/scripting-1.html#the-script-element) that the only difference between this event and the load event (aka “onload”) is that load only fires for externally loaded script files, whereas this event fires for both external and inline script elements.

    So, one could conclude that this event is only useful if you care to track the execution of inline script elements, otherwise you’d just use the much more ubiquitous and well known load event. I’m not really able to think of a great use case for tracking inline script elements finishing executing. Almost all such tracking of an inline script element would be from a script loader or dependency manager or other such code generator which created a new inline script element and did script injection to execute it. But in those cases, since JS is single threaded, and since such inline injection executions happen synchronously, you already “know” when that inline snippet finishes running because that’s the next line of your code after you injected it. :)

    I suppose some niche uses might involve passively observing all script element behavior on the page, or developer tools, or things like that. But I think from what I understand, this event probably won’t have much added value for general developers over load, and could quite possibly confuse things if someone listened to both events.

  2. beforescriptexecute works too! So you can get when the script loaded and how long it took to execute. Pretty cool.

    var time = new Date().getTime();
    var start;
    document.addEventListener('beforescriptexecute', function(e){
    	start = (new Date().getTime() - time);
    }, false);
    document.addEventListener('afterscriptexecute', function(e){
    	var end = new Date().getTime() - time;
    	var total = end - start;
    	console.log('Script executed: ', e.target.src, start, end, '( '+total+' )');
    }, false);
    
  3. joe

    Hi Mike,
    beforescriptexecute ??
    Do not work for me.
    (Firefox 17.0.1 and win7)

  4. qgustavor

    There are security issues related to this?

Wrap your code in <pre class="{language}"></pre> tags, link to a GitHub gist, JSFiddle fiddle, or CodePen pen to embed!