Javascript singleton: access outer attribute from inner function

Question

// i = inner, o = outer, f=function, a=attribute
var singleton = function() {
 var iF = function() {
    return this.oA; // returns undefined
 }
 return {
  oF: function() {
   this.oA = true;
   return iF();
  },
  oA: false
 };
}();

singleton.oF();

If singleton were a class (as in a class-based language), shouldn't I be able to access oA through this.oA ?

The only way I've found of accessing oA from iF is by doing:

return singleton.oA; // returns true (as it should)

I don't know why, but accessing oA through the singleton base object makes me feel kind of... dirty. What am I missing? What is this.oA actually referring to (in a scope sense of view)?

Answer 1

The main point here is that there are no classes in javascript . You need to live without them. You can only emulate some of their characteristics .

The this keyword in javascript refers to the object which invoked the function. If it is a function in the global object this will refer to window . If it is a constructor function and you invoke it with the new keyword, this will refer to the current instance.

There is a simple thing you can do, if you want to keep oA public, and access it from a private function.

// i = inner, o = outer, f=function, a=attribute
var singleton = (function() {

 // public interface
 var pub = {
  oF: function() {
   this.oA = true;
   return iF();
  },
  oA: false
 };

 // private function
 var iF = function() {
    return pub.oA; // returns public oA variable
 }

 // return public interface
 return pub;
})();​

Notice that I wrapped the whole singleton function in parens . The reason this convention is so popular is that it helps you to know if a function will be executed immediately (as in this case). Imagine if your function gets bigger , and when you look at the code it wouldn't be obvious if singleton is a function or an object that a self-invoking function returns. If you've got the parens however, it is obvious that singleton will be something that the function returns immediately.