You want to implement overloaded methods in your JavaScript code. When a method is assigned to any object, there can only be one instance of that property. It is not possible in JavaScript to assign multiple same-named properties. For example, the following code will not work.

   Source: /website/ROOT/ajax articles/javascript/overloaded.html
   var cls = new Object();
   cls[ "method"] = function() {
   info( "method1", "hello");
   }
   cls.method();
   cls[ "method"] = function() {
   info( "method2", "hello");
   }
 cls.method();

In the example code, there are two assignments to the method property. The cls.method method is called twice, and for each call the function implementation called is the last assignment value. The code is trivial and is meant to illustrate that you cannot overload a method by assigning it. Overloading a method is useful in situations where a variable number of parameters are going to be called on a method. Since there are no type declarations, overloaded methods will vary in the number of parameters. The logic used is that if the method is called with five parameters, then an overloaded method that processes five parameters will be called. If the overloaded method does not exist, the default implementation that was initially assigned to the property will be used. Solution The implementation of the overloaded method is as follows.

   Source: /website/ROOT/scripts/jaxson/common.js
   overloaded : function(instance, funcIdentifier,  newFunc) {
   var overloadedPrototype = function() {
   var embeddedFunc = __embedded;
   var overloadedFunc = __newFunc;
   if (arguments.length == __paramCount) {
   overloadedFunc.apply(this, arguments);
   }
   else if (typeof(embeddedFunc) ==  "function") {
   embeddedFunc.apply(this, arguments);
   }
   }
   var origFunc;
   if (!instance[funcIdentifier]) {
   origFunc = function() { };
   }
   else {
   origFunc = instance[funcIdentifier];
   }
   instance[funcIdentifier] =  Generics.expand(overloadedPrototype,
   {
   __embedded : origFunc,
   __newFunc : newFunc,
   __paramCount : ParamCount(newFunc)
   });
 },

In the implementation, JavaScript generics are used to expand the overloadedPrototype function. But added to this expansion is a twist not used previously. Look at the __paramCount identifier. If the identifier is cross-referenced, then __paramCount when it is expanded will reference a numeric value. This means that the expanded function will be hard-coded, but because JavaScript generics are used, this is not a bad thing. The performance will be faster because there is no need to calculate the number of parameters that the overloadedFunc function has. To use the overloaded method, the following code is used:

   function FunctionNoParam() {
   }
   function FunctionOneParam(param) {
   info("FunctionTwoParam",  "param=" + param);
   }
   function FunctionTwoParam(param1, param2) {
   info("FunctionTwoParam", "param1="  + param1 + " param2=" + param2);
   }
   var cls = new Object();
   cls.value = "original";
   cls.example = function() { info(  "default", "hello"); }
   ops.overloaded(cls, "example",  FunctionNoParam);
   ops.overloaded(cls, "example",  FunctionOneParam);
   ops.overloaded(cls, "example",  FunctionTwoParam);
   cls.example("one param example");
 cls.example("first param",  "second param");

Three functions are defined: FunctionNoParam, FunctionOneParam, and FunctionTwoParam. These functions serve as overloaded functions with a varying number of parameters. The cls variable is a generic JavaScript object with no methods or parameters. The data member value is assigned dynamically to the default method. After the default has been assigned, the method example is overloaded with the three overloaded functions using the ops.overloaded function. Once the methods have been overloaded, they can be called with a varying number of parameters. The overloaded methods, for example, will then sequentially find the correct method to call. When implementing overloaded methods, keep the following points in mind:

• The overloaded method JavaScript generics expansion was similar to that shown in previous articles. The only additional twist was the hard-coding of the parameter count. Using traditional programming practices, you would not do that, but using JavaScript

generics it is trivial and recommended.

• When overloading methods, you need to provide a default implementation if you want it.

• You need to support not only the number of parameters to determine what you want to call, but also the type. This is a much more common use case, after all. A method that accepts a string could be overloaded by a variant that accepts an array and calls the string version for each element.

• Overloading methods is not possible according to types, but is made according to parameter count.

• You could implement overloaded types that filter on specific types. For example, you could implement an overloaded method filter that queries the presence of a specific object value. To do that, you can combine the proxy with the overloaded articles. Dynamic Content articles When building Ajax applications, you’re creating user interfaces that interact with the data on the server side. Building a user interface includes multiple aspects that could be considered unrelated. For example, it requires a number of elements on a form. You need to place these elements properly and verify them. The placing and verification could be considered unrelated, because verification can proceed regardless of how the elements are placed, and vice versa. This article doesn’t attempt to dig through the details of how to place elements so that their usability is correct. Instead, this article digs through topics that focus on algorithms such as element verification, HTML dialog box generation, and dynamic layout generation.