Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Prototype vs. Not, what are benefits?

Here I made two objects; one has accessor methods created in the constructor, the other in the prototype. Why would one choose one of these over the other?

function spy1(name){
  this.name = name;
  var secret;
  this.setSecret = function(message){
    secret = message;
  };
  this.getSecret = function(){
   return secret;
  };
}

function spy2(name){
  this.name = name;
  this.secret;
  /* (see comment) was:
  var secret;
  */
}
spy2.prototype.setSecret = function(message){
  this.secret = message;
  /*was:
  secret = message;
  */
};
spy2.prototype.getSecret = function(){
  return this.secret;

  /*was:
  return secret;
  */
};

bond = new spy1("007");
smart = new spy2("86");

bond.setSecret("CONTROL is a joke.");
smart.setSecret("The British Secret Service is for sissies.");
like image 393
Shawn J. Goff Avatar asked Aug 23 '09 19:08

Shawn J. Goff


3 Answers

The primordial differrence is that in your first example, without prototype, the getSecret and setSecret function implementation will reside on every instance of spy1.

On your second example, the functions are defined on the prototype, and all instances refer to them directly, you can test it:

var bond = new spy1("007"),
    bond2 = new spy1("007");

bond.getSecret === bond2.getSecret; // <-- false since they are two functions

var smart = new spy2("86"),
    smart2 = new spy2("86");


smart.getSecret === smart2.getSecret; // <-- true since is the same function
                                      // on all instances

Also note what @T.J. commented, in your second example, using the prototype, you don't have access to the constructor function closure, and for that you are making a window.secret global variable.

If you intend to work with privileged methods, extending the prototype is not an option, all the methods that need access to the variables defined within the scope of the constructor function need to be declared inside of it...

See also: Closures.

like image 198
Christian C. Salvadó Avatar answered Oct 23 '22 10:10

Christian C. Salvadó


In your first example, you're creating new functions for each instance of the object whenever you instantiate a new one. In the second, only a single copy of the function is created which is used by all the instances.

The second way can save memory. You can also use prototype chaining to implement inheritance.

Btw, your second example won't work as written. the secret variable in spy2 is local to the constructor. In the setSecret and getSecret functions in the prototype, you're accessing a single global variable.

like image 36
jimr Avatar answered Oct 23 '22 12:10

jimr


With the second version you end up with a cleaner "constructor".

like image 26
Flavius Stef Avatar answered Oct 23 '22 12:10

Flavius Stef