JavaScript Object Oriented

Let's Create an Object

1 2 3

function myObject(){   };

Congratulations, you just created an object. There are two ways to create a JavaScript object: they are 'Constructor functions' and 'Literal notation'. The one above is a Constructor function, I'll explain what the difference is shortly, but before I do, here is what an Object definition looks like using literal notation.

1 2 3

var myObject = {   };

Literal is a preferred option for name spacing so that your JavaScript code doesn't interfere (or vice versa) with other scripts running on the page and also if you are using this object as a single object and not requiring more than one instance of the object, whereas Constructor function type notation is preferred if you need to do some initial work before the object is created or require multiple instances of the object where each instance can be changed during the lifetime of the script. Let's continue to build on both our objects simultaneously so we can observe what the differences are.

Defining Methods and Properties

Constructor version:

1 2 3 4 5 6

function myObject(){     this.iAm = 'an object';     this.whatAmI = function(){         alert('I am ' + this.iAm);     }; };

Literal version:

1 2 3 4 5 6

var myObject = {     iAm : 'an object',     whatAmI : function(){         alert('I am ' + this.iAm);     } }

For each of the objects we have created a property 'iAm' which contains a string value that is used in our objects method 'whatAmI' which alerts a message.

Properties are variables created inside an object and methods are functions created inside an object.

Now is probably as good a time as any to explain how to use properties and methods (although you would already have done so if you are familiar with a library).

To use a property first you type what object it belongs to - so in this case it's myObject - and then to reference its internal properties, you put a full stop and then the name of the property so it will eventually look like myObject.iAm (this will return 'an object').

For methods, it is the same except to execute the method, as with any function, you must put parenthesis after it; otherwise you will just be returning a reference to the function and not what the function actually returns. So it will look like myObject.whatAmI() (this will alert 'I am an object').

Now for the differences:

• The constructor object has its properties and methods defined with the keyword 'this' in front of it, whereas the literal version does not.
• In the constructor object the properties/methods have their 'values' defined after an equal sign '=' whereas in the literal version, they are defined after a colon ':'.
• The constructor function can have (optional) semi-colons ';' at the end of each property/method declaration whereas in the literal version if you have more than one property or method, they MUST be separated with a comma ',', and they CANNOT have semi-colons after them, otherwise JavaScript will return an error.

There is also a difference between the way these two types of object declarations are used.

To use a literally notated object, you simply use it by referencing its variable name, so wherever it is required you call it by typing;

1	myObject.whatAmI();

With constructor functions you need to instantiate (create a new instance of) the object first; you do this by typing;

1 2	var myNewObject = new myObject(); myNewObject.whatAmI();

Using a Constructor Function.

Let's use our previous constructor function and build upon it so it performs some basic (but dynamic) operations when we instantiate it.

1 2 3 4 5 6

function myObject(){     this.iAm = 'an object';     this.whatAmI = function(){         alert('I am ' + this.iAm);     }; };

Just like any JavaScript function, we can use arguments with our constructor function;

1 2 3 4 5 6

function myObject(what){     this.iAm = what;     this.whatAmI = function(language){         alert('I am ' + this.iAm + ' of the ' + language + ' language');     }; };

Now let's instantiate our object and call its whatAmI method, filling in the required fields as we do so.

1 2	var myNewObject = new myObject('an object'); myNewObject.whatAmI('JavaScript');

This will alert 'I am an object of the JavaScript language.'

FOR EXAMPLE     use above code  and save  cunsturctortype.html:

<script>

function myObject(){

    this.iAm = 'an object';

    this.whatAmI = function(){

        alert('I am ' + this.iAm);

    };

};

var myNewObject = new myObject();

myNewObject.whatAmI();

</script>

and another  example of    literal  type   save file name lietraltype.html:

<script>

var myObject = {

    iAm : 'an object',

    whatAmI : function(){

        alert('I am ' + this.iAm);

    }

}

myObject.whatAmI();

</script>