JavaScript Object-Oriented Programming Part 1

Keeping Things Tidy

Let’s say we want to keep all our properties and methods in the same place – in the Circle() constructor function. There are many ways to do this. Let’s first examine inner functions. An inner function is a function within a function (say that sentence quickly ten times!). Here’s what they let us do:

function Circle(radius){   
 function getArea(){  
   return (this.radius*this.radius*3.14);  
 }  
 function getCircumference(){  
   var diameter = this.radius*2;  
   var circumference = diameter*3.14;  
   return circumference;  
 }  
this.radius = radius;  
this.getArea = getArea;  
this.getCircumference = getCircumference;  
}

It’s the same code, except that we’ve moved the functions. Now, inside our two functions, instead of this.radius, we could use just plain old radius because inner functions can access local variables within outer functions. Thus, it would be able to access the radius local variable passed as an argument to the Circle() constructor. Therefore, we could have just as easily used:

function Circle(radius){   
 function getArea(){  
   return (radius*radius*3.14);  
 }  
 function getCircumference(){  
   var diameter = radius*2;  
   var circumference = diameter*3.14;  
   return circumference;  
 }  
 this.radius = radius;  
 this.getArea = getArea;  
 this.getCircumference = getCircumference;  
}

Ok, now let’s change the radius of an object and get its area:

bigCircle.radius=50;   
alert(bigCircle.getArea()); // displays 31400

But wait! It returns 31400, rather than the expected 7850. What’s wrong? Well, radius refers to the value we passed to the Circle() constructor function, not the value of the object. So when we change the object’s radius, the methods getArea() and geCircumference(), keep on using the old radius. So, we really shouldn’t use just plain old radius. Instead, we need to use this.radius, as it refers to the current object’s radius, whether this property changes after the object is created or not.

Ok, so now we’ve created a self-contained object constructor – the function that defines an object. Let’s look at another way we can create functions inside our Circle() constructor:

function Circle(radius){   
 this.radius = radius;  
 this.getArea = function(){  
   return (this.radius*this.radius*3.14);  
 }  
 this.getCircumference = function(){  
   var diameter = this.radius*2;  
   var circumference = diameter*3.14;  
   return circumference;  
 }  
}  
 
var bigCircle = new Circle(100);  
var smallCircle = new Circle(2);  
 
alert(bigCircle.getArea()); // displays 31400  
alert(smallCircle.getCircumference()); // displays 12.56

Here, we’ve encountered another way to define a function. We can use:

functionName = function([parameters]){   
 // function body  
}

In this way, we can create parameters:

functionName = function(parameter1,parameter2,parameter3){   
 //function body  
}

While functions aren’t created this way very often, when we’re creating objects, they can be useful shortcuts. These processes also help avoid conflicts with function names. For instance, another object can have a different function with the same name, for example getArea(), without causing a conflict. This is possible because these functions are encapsulated inside an object constructor.

Go to page: 1 | 2 | 3 | 4

Free book: Jump Start HTML5 Basics

Grab a free copy of one our latest ebooks! Packed with hints and tips on HTML5's most powerful new features.

No Reader comments

Comments on this post are closed.