John Resig, en su artículo JavaScript Method Overloading, presenta una forma simple de hacer sobrecarga de métodos en javascript. La idea es construír una función que se encargue de mapear, en función del número de parametros recibidos a las funciones que realmente hacen el trabajo. De ese modo es posible construir funciones con lógica diferente de acuerdo a los argumentos recibidos. Dado que las versiones actuales de Javascript no permiten definir tipos para los argumentos, no es posible hacer una distinción al estilo Java, sin embargo no deja ser interesante la posibilidad.

El código es bastante simple, pero efectivo

// addMethod - By John Resig (MIT Licensed)
function addMethod(object, name, fn){
     var old = object[ name ];
     if ( old )
         object[ name ] = function(){
             if ( fn.length == arguments.length )
                 return fn.apply( this, arguments );
             else if ( typeof old == 'function' )
                 return old.apply( this, arguments );
         };
     else
         object[ name ] = fn;
} 

// Now setup the methods
function Users(){

  addMethod(this, "find", function(){
  // Find all users...
  });

  addMethod(this, "find", function(name){
    // Find a user by name
  });

  addMethod(this, "find", function(first, last){
    // Find a user by first and last name
  });
}

// Now use the methods
var users = new Users();
users.find(); // Finds all
users.find("John"); // Finds users by name
users.find("John", "Resig"); // Finds users by first and last name
users.find("John", "E", "Resig"); // Does nothing

Un problema que puede llegar a tener es la disminución en la performance ya que cada vez que se invoque una funcion sobrecargada se debe pasar por un proceso recursivo de elegir cual de todas las sobrecargas de la función se va a ejecutar. Como se puede ver del código es un proceso recursivo, donde primero se ejecuta la última definida, si esa no corresponde, se pasa a la anterior, y asi sucesivamente, por lo que cuantas mas sobrecargas se hagan menor performance se tendrá. De la anterior la recomendación sería definir las sobrecargas en orden creciente de uso, la más usada al final o no hacer sobrecarga en funciones de mucho uso . Otra alternativa podría ser la de implementar una forma de sobrecarga que no haga uso de la recursión sino de una decisión simple.

Ver este tipo de cosas siempre es bueno, y útil para aprender cosas nuevas como por ejemplo fn.length que permite conocer el número de argumentos que existen en la definición de una función (fn)

Visto en: http://ajaxian.com/archives/javascript-method-overloading