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 specific 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?

Track.js Error Reporting

Upcoming Events

Recent Features

  • 5 More HTML5 APIs You Didnât Know Existed

    The HTML5 revolution has provided us some awesome JavaScript and HTML APIs.  Some are APIs we knew we've needed for years, others are cutting edge mobile and desktop helpers.  Regardless of API strength or purpose, anything to help us better do our job is a...

  • CSS Gradients

    With CSS border-radius, I showed you how CSS can bridge the gap between design and development by adding rounded corners to elements.  CSS gradients are another step in that direction.  Now that CSS gradients are supported in Internet Explorer 8+, Firefox, Safari, and Chrome...

Incredible Demos

  • From Webcam to Animated GIF: the Secret Behind chat.meatspac.es!

    My team mate Edna Piranha is not only an awesome hacker; she's also a fantastic philosopher! Communication and online interactions is a subject that has kept her mind busy for a long time, and it has also resulted in a bunch of interesting experimental projects...

  • MooTools 1.2 OpenLinks Plugin

    I often incorporate tools into my customers' websites that allow them to have some control over the content on their website. When doing so, I offer some tips to my clients to help them keep their website in good shape. One of the tips...

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.

    • Brandon

      Just wanted to add some details to what Kyle said, the fact that this event allows users to know when inline scripts ran is already a use that no other method could provide, especially important for software development (add-ons).

      Furthermore, unlike the load event, afterscriptexecute will only trigger when scripts executes, while the load event will also trigger for every single image that loads, or other element that triggers the same event. As such, afterscriptexecute is focused just on what the user wants and is less resource intensive than load on a page that has more than script elements triggering the same events.

      This event, along with beforescriptexecute, are not just for some niche uses, they are in fact very useful for developers and its value is everything but irrelevant, especially since there isn’t any other way of listening to inline scripts unless the developer wrote it himself.

  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!