Javascript module pattern: When to go private with methods? Getters/setters? Room for improvement?

Question

I'm working with a pattern that looks like so (pseudo example):

var FOO = (function(foo) {

    var foo = foo || {},
    setThis = 'someValue';

    //--------------------------------------------------------------------------
    //
    // Public methods:
    //
    //--------------------------------------------------------------------------

    foo.init = function(bar) {

        this.blah = [];

        // Constructor stuff here...

    };

    foo.doSomething = function(bar) {

        if (bar) {

            this.doSomethingElse();

            // Stuff here...

        }

    };

    foo.doSomethingElse = function() {

        // Stuff here...

    };

    //--------------------------------------------------------------------------
    //
    // Private methods:
    //
    //--------------------------------------------------------------------------

    foo._imPrivate = function() {

        // ... stuff here ...

        this.blah = xyz; // References this.

    };

    foo._morePrivate = function(el) {

        // No reference to this.

    };

    foo._otherPrivate = function(el) {

        // No reference to this.

    };

    return foo; // Expose the methods.

}(FOO || {}));

Instanciated like so:

window.onload = function() { FOO.init(stuff); }

Three questions:

1. If my "private" methods don't reference this, should I just make them "standard" functions (i.e. function _imPrivate() { ... }, for example)? Reason why I ask: I have a few methods that reference this, but I don't want to give them public access; I also have a few "utility" methods that don't reference this... Can the methods that reference this be standard functions (in context of the module pattern)?
2. Could someone provide an example of how I would implement a setter for the setThis variable?
3. Do you see any room for improvements in the above code?

Answer 1

The "private" methods aren't private at all, they're public. The OP doesn't seem to take any advantage of closures available from the use of an immediately invoked function expression (IIFE).

The value of a function's this is set by how you call a function, it isn't static (unless you use ES5 bind). It has nothing to do with "context" (at least not in the way context is used in ECMA-262, which is how the word should be used in the context of javascript).

Douglas Crockford's Private Members in JavaScript will help.

If you post a real example of what you are trying to do, you will likely get more help on how to exploit the module pattern in its implementation.

Answer 2

1.

You can do _imPrivate.call(this, arg1, arg2,...);

And in this case this in the _imPrivate function will refer to the particular instance.

2.

var setThis = 'someValue';

foo.setter = function(value) {
    setThis = value;
};