Question

I am creating a custom object to be used in some internal applications where I work. I researched some ways to go about doing this – and this is what I came out with.

function ISGrader(text)
{
this.text = text;

this.printInfo = function(){
    alert("Object working " + text);    
}

this.putGrade = function(score)
{
           alert(score);
}
 }

I believe this shows constructor-type functionality, as well as some simple starter methods that I will build on.

Is the above good practice or is there another way that is more standard?

Answer 1

I prefer a pattern similar to the one below. You can think of it as a 4-step approach:

(function(parent) {

// 1. Declare private variables and functions that will be
// accessible by everybody within the scope of this 
// function, but not outside of it.
var doSomethingAwesome = function() { .. }; // private function
var coolInteger = 42; // private variable

// 2. Create the constructor function
function ISGrader() {
    ..
}

// 3. Create shared public methods on the prototype object.
// These will be created only once, and shared between all objects
// which is more efficient that re-creating each method for each object.
ISGrader.prototype.printInfo = function() { .. };
ISGrader.prototype.putGrade = function(score) { .. };

// 4. Expose the constructor to the outside world.
parent.ISGrader = ISGrader;

})(window);

The reason why everything is enclosed inside a self-executing anonymous function is to ensure the private variables we create inside don’t leak outside to the enclosing scope, and to basically keep things clean.

Another benefit of declaring the constructor like this is that you can change the parent object easily from say window to a further namespaced object by changing a single word.