There are ultimately two 'proper' ways to define a class as you have already
touched on.  To clarify:-

Option A.

function MyClass(value)
{
   var x = 0, y = 0  //private class level variables

   this.a = value  // public member

   function fnPrivateStuff()  // private functions
   {
   ...
   }

   this.publicStuff = function()  // public method
   {
   ...
   }

}

This approach provides much stronger encapsulation (x,y for example can only
be referenced from a function defined inside the class) it is therefore more
suited to large complex objects.   However as pointed out instances of this
type are more expensive to create so may not be the best choice if a large
number are to be created.  A more important point IMO is that implementing a
design that incoporates generalised and specialised classes (inheritance) is
awkward in this approach.

Option B

function MyClass(value)
{
   this.x = 0; this.y = 0
   this.a = value
}
MyClass.prototype.fnPrivateStuff = function()
{

}
MyClass.prototype.publicStuff = function()
{

}
MyClass.prototype.publicStuff2 = function()
{

}

This approach has much weaker encapsulation.  In fact it has no
encapsulation at all.  The distinction between public and private members
would have to rely on conventions such as the use of a preceeding underscore
in member names.  Creating a large number of instances of this class is
cheaper since the created instance only needs to carry the value the member
variables not the functions.  This approach's biggest strength is in
implementing specialisation of general classes:-

function MyDerivedClass(value1, value2)
{
   MyClass.call(this, value1)  //Base class constructor
   this.b = value2
}
MyDerivedClass.prototype = new MyClass()
MyDerivedClass.prototype.somePublicMethod = function()
{

}
MyDerivedClass.prototype.publicStuff2 = function() // override
{

}

On thing often missed in the prototype approach is that default values for
non-function members can also be defined.  This further reduces the cost of
creating instances of these classes where member values are only actually
created when a new value is assigned to them.   The MyClass above can look
like this:-

function MyClass(value)
{
   this.a = value
}
MyClass.prototype.x = 0
MyClass.prototype.y = 0

HTH,

Anthony

Net neutrality
class free society
school is over (that one was deleted by ms)

We don't want to be "classified" as lusers, users or idiots.
--------------------------------------------
The net as is, is a keeper.

We paid for it for 10 years plus.

We own it.

We shall cause uncomfort to anyone,
tresspassing our ways and means and believes
of the Internet as is.

Never without our consent.

We don't want an iraque modell of conquest
to hush potentil progress other than fuzzy Texan business laws..
--------------
Let the old guys the US Congress know that !

=========================

I am not a Bush fan, but I know when he rides a bike,
he is clear in his mind.

He just does not understand to communicate beyond his
education.

.