When developing OOJS, should I reference the protoype function, or the variables version?

Question

As the title (sort of) explains, when I'm prototyping in JS, and I need to reference another function of the object, should I access the protoypal version of it, or the local variables version? Is there any (major) overhead issues involved with either one?

//starting off
Foo = function(){ }

Foo.prototype.ShowMessage = function(msg){
  alert(msg);
}

//method 1
Foo.prototype.Validate = function(msg){
  //some validation stuff...
  if(!Valid){
    this.ShowMessage("Please check your inputs, there seems to be a problem with them.");
  }
}

//method 2
Foo.prototype.Validate = function(msg){
  //some validation stuff...
  if(!Valid){
    Foo.prototype.ShowMessage("Please check your inputs, there seems to be a problem with them.");
  }
}

I'd prefer method 1, purely because it's easier to type this, than Foo.prototype, but does it matter performance wise which one? Or am I just MoM-ing this?

Answer 1

You should definitely use

this.showMessage("msg");

The second version simply would not work properly at all. Why? Because that invocation of showMessage would result in its "this" variable pointing to that prototype object and not the instance. That would almost certainly not be what you want.

Answer 2

In case you want to have a instance method you should use this.* reference. Otherwise if you want to have a kind of class method you can use the following:

//starting off
Foo = function() {
};

Foo.prototype.ShowMessage = function(msg) {
    alert("Instance message: " + msg);
};

Foo.ShowMessage = function(msg) {
    alert("Class message: " + msg);
};

Foo.prototype.Validate = function(msg) {
    //some validation stuff...
    if (!Valid) {
        this.ShowMessage("Please check your inputs, there seems to be a problem with them.");
        Foo.ShowMessage("Please check your inputs, there seems to be a problem with them.");
    }
};