Javascript, getting away from 'this' and using local scope

Question

In a typical js class, all calls to member functions must be preceded by this. I was looking at a technique that would let me create a library of inter-dependent STATIC functions and relying on closure/scope to make things a bit easier.

Example:

var Singleton={
  //main entry point
  // call with fn name, args...
  call:function(){
    var args=[];
    if (arguments.length==0) {
      return;
    }
    // get the fn name
    var fn=arguments[0];
    var x;
    // make args array
    for (x=1;x<arguments.length;x++) {
      args[args.length]=arguments[x];
    }
    // I want to get rid of this part
    // See below for what I wish
    // Here I have access to fns below due to hoisting in js
    // so I put them in a map...
    var fns={
      test:test
      // etc, more like this I do not want to type/maintain
    }
    // ... all so I can do this
    // get my function.
    var fun=fns[fn];
    // instead of that, I would like to "override whitespace" and
    // say something like:
    // var fun=['fn_name'];
    // so I can index into local scope and get a fn
    //
    // log error if not found
    if (typeof fun=='undefined') {
      loge('Singleton: function not found:'+fn);
      return;
    }
    // ok, run the function
    return fun.apply(window,args);
    // the test fn accesses test2() without dot notation
    function test(a){
      // Note: here in test fn it can access test2() 
      // without using this.test2() syntax
      // as you would in normal objects
      var s=test2();
      alert(s+' test:'+a);
    };
    function test2(){
      return 'test2';
    };
  }
}

I was hoping someone more familiar with advances in javascript might have advice on how to emulate an "implied but unnecessary this", it always struck me as strange that this defaults to window, and wouldn't it be nice if this could be pointed to an anonymous object with the local scope attached.

I would love to say ['localObject'] to get something in scope.

Edit:

After seeing some of the responses, I will restate this in the form of a challenge:

What I am looking for is a syntax cheat, a way to, as @Varuna put it, "1. Access static methods without using this variable i.e. they will remain global to one another. 2. Do not want to maintain a local array for static methods and want to achieve with in the local scope itself."

Put differently, I need to have the declared functions Register themselves, but I don't want to state the function name more than once. I suppose @Varuna has a solution using eval to access the local scope.

The following approach wont work:

var o={};
o['fn']=function fn(){};
o['fn2']=function fn2(){};

...because you have to state the fn name twice, but closure is preserved.

And this:

var a=[
  function fn(){}
  ,function fn2(){}
];
Register(a);

Will not work because, AFAIK, you lose closure, ie. fn2 cannot see fn. Which also makes the following declarative style a "this nightmare":

window.MINE={
  fn:function fn(){
    //this?
    // want to say fn2(), not this.fn2(), nor MINE.fn2()
  }
  ,fn2:function fn2(){
    //this?
  }
  ,deeper:{
    //more
  }
};

But something like this might work, if you created a weird property that does the registration on assignment:

var registar=new Registar();
registar.reg=function fn(){};
registar.reg=function fn2(){};
//then access
var fn=registar.getFn(n);
// or
var fn=registar._[n];

The above relies on js properties and having access to fn.name, which is not available in all cases AFAIK.

Answer 1

If I understand correctly, you want to create objects that:

• have static members
• ... which can be accessed without using the this notation

The easiest solution (assuming I've properly understood your query), would be to simply use a closure to store your stratic fields, access them directly by name, then explicitly add them as object members.

Consider:

var myConstructor = (function(){

    var foo = 'someStaticField';
    var bar = function(){
        alert('A static method returns ' + foo);
    };

    return function(){
        return {
            foo : foo,
            bar : bar
        };
    };

})();
var myInstance = new myConstructor();