Javascript change function arguments

As delnan said in the comments, it seems like what you're trying to do is essentially "rename" the variables which are local to a function. Like he said, this is not possible (and for good reason too! Could you imagine debugging that? maaan...)

Anyway, I don't know exactly why you'd want that, but Javascript is a flexible language and you could probably get close using a more sane method. It's hard to know exactly what you're trying to achieve, but perhaps this information might get you on the right track:

• The arguments which are passed to a function at call time are referenced in a variable named arguments.

  function f() {
    console.log(arguments);
  }
  f(); // []
  f(1, 2); // [1, 2]
  

• You can call a function with an arbitrary list of arguments using .apply, which is a method on the Function prototype. It takes 2 parameters. The first is the object which will be this inside the function call, and the second is an array of arguments.

  f.apply(null, []); // []
  f.apply(null, [1, 2, 3]); [1, 2, 3]
  

Applying this in your situation, perhaps this is what you're after:

function f() {
    console.log.apply(console, arguments);
}

I've got a simpler solution similar to the accepted answer for anyone out there that is looking. Works in Chrome, Firefox, Safari, IE7+

Solution

function SetArgList(fn, args) {

   var fnbody = fn.toString().replace(
         /^\s*function\s*[\$_a-zA-Z0-9]+\(.*\)\s*\{/, //BEWARE, removes original arguments
         ''
      ).replace(
        /\s*\}\s*$/,
        ''
      );

   return new Function(args, fnbody) 

}

How to use

Just redefine your original function like this using SetArgList:

function main() {
   alert(hello);
   alert(world);
}

main = SetArgList(main, 'hello,world');

main('hello', 'world');

In my solution there's no need for an array but you could edit it, my function only requires argument names separated by a comma.

you can use .apply: this works for me:

 f = function(a,b,c){ 
    console.log(a,b,c); 
}; 
var args = ["a", "b", "c"];  
f.apply(this, args); //print "abc"

using arguments:

f = function(){ 
    for(var key in arguments) {
        console.log(arguments[key]);
    }
}; 
var args = ["a", "b", "c"];  
f.apply(this, args); 

it's that you looking?

As said before, you can't do it the way you want, you're breaking lexical scoping. However, here a minimalism version of the way you can implement it (a lot of improvements should be done !). The only thing required is that you function has the named parameter in arguments.

function getType( el ) {
    // TODO
    return "";
}

function addMethod( obj, name, typedef, func ) {
    var argumentsLength = typedef.length;

    obj[ name ] = function() {
        var len = arguments.length, i = 0;

        if( argumentsLength != len )
        {
            throw new TypeError( "Wrong number of arguments for method " + name );
        }

        for( i = 0; i < len; i++ )
        {
            // TODO better type checking
            if( getType( arguments[i] ) != getType( typedef[i] ) )
            {
                throw new TypeError( "Wrong type for arguments number " + i + " for method " + name );
            }
        }

        return func.apply( obj, arguments );

    };
};


var o = {};

addMethod( o, "log", [Array, String], function( arr, str ) {
      // arguments MUST be explicitly declared above
      console.log( arr, str );
});
o.log( ["a"], "b" ); // OK
o.log( "a", "b" ); // TypeError
o.log( ["a"], "b", "c" ); // TypeError

I found a solution that only works on webkit browsers:

f = function(){ console.log(a,b,c); };
fx = eval(
    f.toString().replace(
        /^function [^\(]*\(\)/,
        "var __temp = function (a,b,c)") 
        + "; __temp");
fx(1,2,3);

This can also be generalized.

[edit] This works for other browsers as well, memory let me down - comments // /**/ in some browsers get discarded.