var F = function(a, b) { this.init(a, b); }; Foo.prototype = { setA : function(name) {

},
setB : function(name) {

},
init : function(a, b) {
    this.setA(a);
    this.setB(b);
}

};

/* * instantiate :) */

var o = new F(‘hello’, ‘world’);

But yeah, if I had to pick - I’d pick your second option (over the first) Jeremy :)

I know that this isn’t supported in javascript, but as an answer to what I like best it’s the answer.

[1] http://docs.python.org/lib/built-in-funcs.html#l2h-57

[2] http://www.delphibasics.co.uk/RTL.asp?Name=Property

Douglas Crockford has more to say on this: http://javascript.crockford.com/private.html

If you’re not going to make any verifications, go straight ahead and set the vars straight away.. but sometimes ("it depends") you might want that little layer for verification purposes, so you can have hybrids. Some properties have getter/setters others don’t…

This would make much more sense if you could protect variables against public access, ie, specify the level of access you wanted for each property (public, private, protected… as in Java or other OO languages). Is there a way to do this I don’t know of? If there isn’t, then it actually makes no difference, since someone using that object can get/set the value without using the getters/setters.

It seems that there’s general agreement on the answer: it depends. It depends on what you’re doing and the complexity of your script.

Thank you everybody for chiming in. I appreciate it.

But say, for example, your object depended upon foo and bar being integers within a certain range, you’d have to do the second so that you could check.

The other alternative, which is the best of both worlds, is to do the following. Unfortunately, browser support is an issue here.

function Foobar() {
    var _bar = 0;
    this.__defineGetter__("bar", function() { return _bar; });
    this.__defineSetter__("bar", function(value) {
        if (value >= 0 && value <= 100) _bar = value; 
    });
}

var x = new Foo();
x.bar = 10;
x.bar = 150;
alert(x.bar);

Java describes it cleanly.. i.e. a a Class encapsulates attributes and methods.. and the word "Class" isn’t re-used again for describing methods. A Class is a class and a method is a method. Of course, there are inner Classes as well.. but they act like a Class. There is no ambiguity.

Flexibility is handy of course. I love Perl as well, where there are many way to do the same thing.. but calling all these things a "function" in javascript is confusing and makes it challenging to debug things for those of us who learned an objected oriented language before javascript.

P.S. love the Dom Scripting book.. Great piece of work.

To keep it simple, I’d propose a third option:

baz.init({foo: 1, bar: 2});

var baz1= new Foobar();
var baz2= new Foobar();

baz1.setFoo != baz2.setFoo

This can be a big problem for memory usage.

You’re almost always better off using the prototype method (for all its warts). On the other hand, I often use nested functions to achieve much the same effect as private methods.

And don’t get me started about the ugly prototype (the library) practice of declaring classes.

With all this in mind, my answer would be: whichever method fits the bill! ;-)

I’ve always found I use more shortcuts and a compact writing style with Javascript as opposed to other languages. For readability purposes I would write method #2 as

function Foobar() {

var foo,bar;
this.setFoo = function(value) { foo = value; };
this.setBar = function(value) { bar = value; };
this.init = function() {
    execute();
};
var execute = function() {
    alert(foo bar);
};

}

If you have restrictions on values that your member variables can have, then use a setter/getter. If you don’t, avoid them. Also, when using setters/getters, I find that it’s better to have a short meaningful name for your setter/getter than to reserve that for your private variable and give the setter/getter a more verbose name.

Therefore, I’d do something like:

var _foo, _bar;

this.foo = function(value) { if(arguments.length == 1) _foo = value; return _foo; }

That way, you can call it like:

obj.foo(3);

alert(obj.foo());

PS: Excuse the formatting, I couldn’t figure out how to get pre working in the comments PPS: I also couldn’t figure out how to enter a plus sign into the comments - the preview seems to strip them off.

A while back I wrote a function to implement class-based inheritance (similiar to Dean Edwards’ Base Class) and told everyone to use that and reference EVERYTHING using "this." It doesn’t exactly prevent memory leaks, but it certainly helps to prevent them, and I have one less path to check when I’m trying to find them.

for obvious reasons, foobar.prototype.setbar is going to (potentially) take up much less memory in the long run than foobar.setbar. It would be nice to find a way to implement private variables using prototypes but unfortunately one doesn’t exist (yet).

Taking this approach allows you to expose properties that might not correspond to directly returning the value of a single member variable - for example, you could expose a ‘FullName’ property that returns a value based on title, first name, and surname.

So I’d go for option 2, but I can understand wanting to keep it simple…