Optimum Implementation
This technique can be generalized to allow the arbitrary interception and loading of methods and libraries respectively, and employing a function that contains an inner function is the optimum approach here. In this scheme, the outer function takes arguments denoting the interceptee, its owner-object, and the name of the library to be loaded; on execution, it replaces the interceptee-reference in the owner-object with a reference to the inner function.
This forms a closure (and what a superb use for those exotic creatures) that makes the outer function's parameters available to the inner function when it executes. It follows that calling the interceptee invokes the inner function, which calls the library-loader before replacing the reference to itself with the original reference to the interceptee. Listing Five (available online; see "Resource Center," page 5) demonstrates this.
AspectJS
The reality is that function interception in JavaScript constitutes a form of meta-programming in an interpreted language, and has many aspect-oriented applications beyond loading on demand. Given that wider context, you can view a call to a library-loader as a "prefix" to the interceptee, and this introduces the notion of functions that act as "suffixes," where a method is called after, rather than before, the invocation of the interceptee.
This leads to the notion of "wrapping" an interceptee with such affixes, which leads from there to the question of affix lifetime. In the on-demand example, the prefix executes just once before it is detached, but there may be instances where an affix should execute for a certain number of times, or even infinitely; the ability to remove an affix explicitly is also desirable. Moreover, multiple affixes may be desirable—in Listing Two there are three loading calls, which suggests applying three discrete prefixes to DisplayMenu, and this introduces the notion of changing their execution order if needed. Then there is the question of exception handling, error checking, and diagnostics, as well as performance, all of which raise significant design questions.
A clear case exists, therefore, for a general-purpose function-interception library that addresses these points, thereby obviating re-invention of the wheel; and AspectJS (www.dodeca.co.uk/ajs_About_AspectJS.htm) is one such resource that is freely available. Encapsulating the mechanics of function interception, it allows (among other things) unlimited numbers of affixes for a given function, with fine control over their type, number, longevity, and execution order. In deference to a venerable tradition, therefore, Listing Six (available online) demonstrates loading a JavaScript library transparently on demand using AspectJS.
This uses the AddPrefix method of a singleton object called AJS to set up the interception. The first two parameters signify the OnMouseClick method of the global object as the interceptee, and the third specifies LoadLib_XHR as the prefix. The fourth is an optional parameter that is passed to the prefix—in this case the name of the library to be loaded—and the final argument specifies that the prefix should be removed after just one execution. The net result is that clicking on the client area of the browser's window causes Hello.js to be loaded, thus allowing a customary greeting to be displayed.
An Open Door
Resolving the downside to on-demand JavaScript lets you exploit its full potential, and generalizing the solution opens the door to a wealth of aspect-oriented techniques. Consolidating the principles of function interception in a reusable library lets you affix methods arbitrarily to virtually any function call. This permits the serious application of AOP techniques to professional web development, thus allowing remote tracing, debugging, and error reporting, along with client-side performance measurement, user-interaction modeling, and others that, as yet, are only a twinkle in the developer's eye.
