How should I operate on "private" members of another object with the same prototype?

Question

In a class-based language like Java, I sometimes take advantage of the fact that a private member of a class is accessible by other objects of the same class. For example,

class BitSet {
    private int[] words;

    public void and(BitSet set) {
        for (int i = 0; i < words.length; i++)
            words[i] &= (i < set.words.length) ? set.words[i] : 0; 
    }
}

Now, I'm working JavaScript using the constructor pattern to create "private" members:

function BitSet() {
    var words = [];

    this.and = function (set) {
        // This is roughly what I'm trying to achieve.
        for (i = 0; i < words.length; i++)
             words[i] &= (i < set.words.length) ? set.words[i] : 0;
    }

    // This would solve the problem,
    // but exposes the implementation of the object and
    // clutters up the API for the user

    this.getWord = function(index) {
        return words[index];
    }
}

I know I should probably be approaching this problem differently (and not so object-oriented). Does anyone have a suggestion for a better pattern?

Answer 1

JavaScript is a prototypal object-oriented programming language, not a classical object-oriented programming language. There are no classes in JavaScript but you can model prototypes as classes due to prototype-class isomorphism:

function CLASS(prototype) {
    var constructor = prototype.constructor;
    constructor.prototype = prototype;
    return constructor;
}

The CLASS function allows you to create prototypes which look like classes. However they are not classes. Unlike classes in other languages prototypes in JavaScript have no access specifiers. Everything must be either public or hidden inside closures:

var BitSet = CLASS({
    constructor: function () {
        this.words = [];
    },
    and: function (set) {
        var length = this.words.length, setWords = set.words;
        for (var i = 0; i < length; i++) this.words[i] &= setWords[i] || 0;
    }
});

In fact it is a good thing that JavaScript doesn't have classes or access specifiers because you really don't need them. Think about it. Do you really need access specifiers in languages like Java either? If everything was public would it really make such a big difference? In my humble opinion it wouldn't.

Some people argue that making everything public is bad because it exposes implementation details and unnecessarily clutters the user API. Not true. Just don't document those properties which you wish to keep private. If the user doesn't need to know about a certain property then just don't document it.

If you need to make a variable private for security purposes then JavaScript has closures. Such properties shouldn't need to be accessed by other objects (even of the same class) anyway. Hence there shouldn't be a situation in which you need to keep a variable private and making it accessible to other classes of objects too.

Finally there are lots of advantages of making properties public:

1. Since the property is public you don't need to create closures inside the constructor function.
2. Methods can be shared on the prototype. Hence all instances of the class share methods.
3. You can separate object initialization from the methods of the object.
4. The code is more readable and maintainable.
5. Object creation is faster.