性能：私有方法原型

Question

Given the object:

object = function ()
{
   var pub = {
      m1: function () {
        m2();
        m3();
      }
   };

   function m2() {
     ...
   }

   function m3() {
     ...
   }

   return pub;
}

This object will be instantiate more than one time. Should I add the private functions to the prototype, so they are not copied in every instance?

What could be a limit, perhaps, to a number X of private methods vs number Y of instances.

Answer 1

In OOP Javascript with ES5, your objects can have 3 types of member.

• public
• private
• priviledged

public members are created in the prototype and can be accessed by anyone.

var MyCustomClass = function() {
};

MyCustomClass.prototype.myPublicMethod = function() {
};

var myCustomObject = new MyCustomClass();
myCustomObject.myPublicMethod();

The private members are created inside the Class constructors and can only be accessed inside the class constructor (you can't access them in the public methods, despite being in the same Class).

var MyCustomClass = function() {
    var m_privateMember; //cannot be accessed outside the constructor
};

The privileged members are actually public members, but declared inside the constructor, so they can use private members.

var MyCustomClass = function() {
    var m_privateMember = 2;

    //Priviledged method (which is a GETTER here)
    this.GetPrivateMember = function() {
        return m_privateMember;
    };
};

var myCustomObject = new MyCustomClass();
console.log(myCustomObject.GetPrivateMember()); //2

That allows you to access the private member in your public methods by calling the priviledged GETTER.

Now, about performance. I am currently using this pattern in a project with over 700 objects with, inside them, more than 12 privates members and a lot more priviledged members (~30) because i don't like using public members (have to define members in 2 different places, the constructor and .prototype, so i just define them all in the constructor, and call the 'initialize' methods at the end of the constructor). And I didn't notice any performance issue. Objects are still being instantiated as fast as it can get. I can't guarranty that there is no performance cost, but IMHO, it is not noticeable.

You can also define properties this way :

var MyCustomClass = function() {
    var myPrivateMember;

    Object.defineProperty(MyCustomClass.prototype, 'myProperty', {
        get: function() {
            return myPrivateMember; 
        },
        set: function(_param) {
             myPrivateMember = _param;
        }
    });
}

var myObject= new MyCustomClass();
myObject.myProperty = 6;
myObject.myProperty; //6

But I don't like it since i prefer calling GetMyProperty(), but its a matter of taste.

You should check Object.definyProperty since i might not have the exact syntax.

---

EDIT for the performance issue.

So I have run some tests in my browser (Chrome 46) and there is no performance hit between private members and public members.

For a ClassA with 12 private members vs a ClassB with 12 public members, I have instantiated 1,000,000 objects of each Class, taking on an average of 10 tests about 250 ms for ClassA and 245 ms for ClassB.

So, feel free to use private members.