Problem You want an effective strategy for implementing proxy methods. Theory The Proxy pattern is defined as an implementation of an interface that acts as a pass-through for the real implementation. Any user of the interface instance will not realize that a particular method call is being rerouted. The full implementation of the Proxy pattern is not the focus of this article; rather, this article focuses on applying the Proxy pattern for a single method. In the alternate way of wiring together two methods, the defined2 method associated with the class instance is wired to first call the new method, and then call the original method. In this form of wiring, you are not implementing the Proxy pattern you are creating a delegate model. The main difference between a proxy and delegate model is that the proxy model is responsible for calling the original implementation, and the delegate model does not have that restriction. Solution Now that you know the difference between the two models and what you want to achieve, let’s examine what the source code should look like, and then convert that source into a general method. Consider the following class declaration.

   Source: /website/ROOT/ajax articles/javascript/proxy.html
   function DefinedClass() {
   }
   DefinedClass.prototype.defined =  function(tstvalue) {
   info("DefinedClass.defined",  "parameter (" + tstvalue + ") arguments count (" +
   arguments.length + ")");
   DefinedClass.prototype.defined.value = 10;
   assertEquals(tstvalue, this.value);
   }

   Source: /website/ROOT/ajax articles/javascript/proxy.html
   var proxyfunc = function(tstValue, toCall,  args) {
   info("proxyfunction", "parameter  (" + tstValue + ") received arg count (" +
   arguments.length + ") original arg count  (" + args.length + ")");
   toCall.apply(this, args);
   }

Implementing the proxy can be a challenge, because the current method implementation (defined) has to be moved. Per the Proxy pattern implementation, the function referenced by the proxyfunc variable has to be called before the current method implementation. The obvious solution is to assign the defined method to the proxyfunc variable reference, as follows: DefinedClass.prototype.defined = proxyfunc This solution is quirky, because the original method is not referenced by proxyfunc. The original method would seem to have disappeared, and when proxyfunc does attempt to call the original method, an error will result. The original method could follow a convention where the method implementation is referenced by another property:

   DefinedClass.prototype.originalDefined =  DefinedClass.prototype.defined;
   DefinedClass.prototype.defined = proxyfunc

proxyfunc, which is responsible for calling the original implementation using convention, knows that the original method is stored in the originalDefined property. So this seems OK, but in fact there is another problem. What if you have a proxy method of a proxy method? Since the originalDefined method is already defined, do you overwrite and lose the original method to be called? Another solution is to extend the convention to the following:

   DefinedClass.prototype.originalOriginalDefined  =
   DefinedClass.prototype.originalDefined;
   DefinedClass.prototype.originalDefined =  DefinedClass.prototype.defined;
   DefinedClass.prototype.defined = proxyfunc

The downside to this solution is that per the convention, the identifier contains a number of original identifiers. The convention requires that a specific proxy method be placed at a specific location; otherwise, the proxy method does not know whether to call originalDefined or orginalOriginalDefined. Another problem is, what if originalDefined referenced a real method? The solution to the proxy method article is not to create new properties, but to create embedded functions. Embedding functions makes it possible to declare a function that is not accessible externally, and the proxy method can be embedded within a proxy method. The generated JavaScript follows:

   DefinedClass.prototype.defined = function() {
   var origFunc = function (tstvalue) {
   info("DefinedClass.defined",  "parameter (" + tstvalue + ") arguments count (" +
   arguments.length + ")");
   assertEquals(tstvalue, this.value);
   }
   var proxyFunc = function (tstValue, toCall,  args) {
   info("proxyfunction", "parameter  (" + tstValue + ") received arg count (" + 
   arguments.length + ") original arg count  (" + args.length + ")");
   toCall.apply(this, args);
   }
   var args = new Array();
   for (var c1 = 0; c1 < arguments.length; c1  ++) {
   args.push(arguments[c1]);
   }
   args.push(origFunc);
   args.push(arguments);
   proxyFunc.apply(this, args);
   }

Two variables, origFunc and proxyFunc, reference functions. The origFunc variable represents the original implementation of the defined method. The proxyFunc variable represents the proxy method that is called before the original method. Both functions are embedded in a function that is responsible for calling the proxy method.

Embedding the functions within a function does not require the proxy method to know what the original function is called. For each instance of embedding, there is a proxy method and the original method. The convention is that the method that embeds the two methods keeps track of who calls whom and what parameters are passed around.

The role of the parent method is to manage the references of the embedded methods, manage the this instance, and manage the parameters. The parent method manages the parameters by considering the arguments as an Array type. The JavaScript-defined arguments object is an array of arguments. The parent method will create a new set of arguments so that the proxy method knows which function to call and has the ability to modify the arguments based on the original object instance. The purpose of creating an array of arguments that contains the arguments relates to the declaration of the proxy method, which will always have as its last parameters the method to call and arguments. Embedding a function within a function has a problem: how do you assign the this reference in the embedded function? JavaScript solves this problem by providing the apply method, which is associated with a function object.