Introduction to Object-Oriented JavaScript

IN THIS ARTICLE

JavaScript is object-oriented to its core, with powerful, flexible OOP capabilities. This article starts with an Introduction to object-oriented programming, then reviews the JavaScript object model, and finally demonstrates concepts of object-oriented programming in JavaScript.

JavaScript review

If you don't feel confident about JavaScript concepts such as variables, types, functions, and scope you can read about those topics in A re-introduction to JavaScript. You can also consult the Core JavaScript 1.5 Guide.

Object-oriented programming

Object-oriented programming is a programming paradigm that uses abstraction to create models based on the real world. It uses several techniques from previously established paradigms, including modularity, polymorphism, and encapsulation. Today, many popular programming languages (such as Java, JavaScript, C#, C++, Python, PHP, Ruby and Objective-C) support object-oriented programming (OOP).

Object-oriented programming may be seen as the design of software using a collection of cooperating objects, as opposed to a traditional view in which a program may be seen as a collection of functions, or simply as a list of instructions to the computer. In OOP, each object is capable of receiving messages, processing data, and sending messages to other objects. Each object can be viewed as an independent little machine with a distinct role or responsibility.

Object-oriented programming is intended to promote greater flexibility and maintainability in programming, and is widely popular in large-scale software engineering. By virtue of its strong emphasis on modularity, object oriented code is intended to be simpler to develop and easier to understand later on, lending itself to more direct analysis, coding, and understanding of complex situations and procedures than less modular programming methods.²

Terminology

Namespace: A container which allows developers to bundle all functionality under a unique, application-specific name.
Class: Defines the characteristics of the object.
Object: An Instance of a class.
Property: An object characteristic, such as color.
Method: An object capability, such as walk.
Constructor: A method called at the moment of instantiation.
Inheritance: A class can inherit characteristics from another class.
Encapsulation: A class defines only the characteristics of the object, a method defines only how the method executes.
Abstraction: The conjunction of complex inheritance, methods, properties of an object must be able to simulate a reality model.
Polymorphism: Poly means "many" and morphism means "forms". Different classes might define the same method or property.

For a more extensive description of object-oriented programming, see Object-oriented programming at Wikipedia.

Prototype-based programming

Prototype-based programming is a style of object-oriented programming in which classes are not present, and behavior reuse (known as inheritance in class-based languages) is accomplished through a process of decorating existing objects which serve as prototypes. This model is also known as class-less, prototype-oriented, or instance-based programming.

The original (and most canonical) example of a prototype-based language is the programming language Self developed by David Ungar and Randall Smith. However, the class-less programming style has recently grown increasingly popular, and has been adopted for programming languages such as JavaScript, Cecil, NewtonScript, Io, MOO, REBOL, Kevo, Squeak (when using the Viewer framework to manipulate Morphic components), and several others.²

JavaScript Object Oriented Programming

Namespace

A namespace is a container which allows developers to bundle up all functionality under a unique, application-specific name. In JavaScript a namespace is just an object containing methods, properties and objects. The Idea behind creating a namespace in JavaScript is simple: one global object is created and all variables, methods and functions become properties of that object. Use of namespaces also minimizes the possibility of name conflicts in an application.

An object is a Namespace:

Let's create a global object called MYAPP

// global namespace

var MYAPP = MYAPP || {};

Here in above code sample we have first checked whether MYAPP is already defined in same file or in another file If yes then use existing MYAPP global object otherwise create empty object called MYAPP which will encapsulate method, functions, variable and object.

We can also create sub namespace:

// sub namespace

MYAPP.event = {};

Below is code syntax for creating namespace and adding variable, function and method:

// Create container called MYAPP.commonMethod for common method and properties

MYAPP.commonMethod = {

  regExForName: "", // define regex for name validation

  regExForPhone: "", // define regex for phone no validation

  validateName: function(name){

    // Do something with name, you can access regExForName variable

    // using "this.regExForName"

  },

  validatePhoneNo: function(phoneNo){

    // do something with phone number

  }

}

// Object together with the method declarations

MYAPP.event = {

    addListener: function(el, type, fn) {

    //  code stuff

    },

   removeListener: function(el, type, fn) {

    // code stuff

   },

   getEvent: function(e) {

   // code stuff

   }

   // Can add another method and properties

}

//Syntax for Using addListner method:

MYAPP.event.addListener("yourel", "type", callback);

Core Objects

JavaScript has several objects included in its core, for example, there are objects like Math, Object, Array, and String. The example below shows how to use the Math object to get a random number by using its random() method.

alert(Math.random());

Note: This and all further examples presume a function named alert (such as the one included in web browsers) is defined globally. The alert function is not actually a part of JavaScript itself.

See Core JavaScript 1.5 Reference:Global Objects for a list of the core objects in JavaScript.

Every object in JavaScript is an instance of the object Object and therefore inherits all its properties and methods.

Custom Objects

The Class

JavaScript is a prototype-based language which contains no class statement, such as is found in C++ or Java. This is sometimes confusing for programmers accustomed to languages with a class statement. Instead, JavaScript uses functions as classes. Defining a class is as easy as defining a function. In the example below we define a new class called Person.

function Person() { }

or

var Person = function(){ }

The Object (Class Instance)

To create a new instance of an object obj we use the statement new obj, assigning the result (which is of type obj) to a variable to access it later.

In the example below we define a class named Person and we create two instances (person1 and person2).

function Person() { }

var person1 = new Person();

var person2 = new Person();

Please also see Object.create for a new and alternative instantiation method.

The Constructor

The constructor is called at the moment of instantiation (the moment when the object instance is created). The constructor is a method of the class. In JavaScript, the function serves as the constructor of the object therefore, there is no need to explicitly define a constructor method. Every action declared in the class gets executed at the time of instantiation.

The constructor is used to set the object's properties or to call methods to prepare the object for use. Adding class methods and their definitions occurs using a different syntax described later in this article.

In the example below, the constructor of the class Person displays an alert when a Person is instantiated.

function Person() {

  alert('Person instantiated');

}

var person1 = new Person();

var person2 = new Person();

The Property (object attribute)

Properties are variables contained in the class; every instance of the object has those properties. Properties should be set in the prototype property of the class (function) so that inheritance works correctly.

Working with properties from within the class is done using the keyword this, which refers to the current object. Accessing (reading or writing) a property outside of the class is done with the syntax: InstanceName.Property; this is the same syntax used by C++, Java, and a number of other languages. (Inside the class the syntax this.Property is used to get or set the property's value.)

In the example below we define the firstName property for the Person class and we define it at instantiation.

function Person(firstName) {

  this.firstName = firstName;

  alert('Person instantiated');

}

var person1 = new Person('Alice');

var person2 = new Person('Bob');

// Show the firstName properties of the objects

alert('person1 is ' + person1.firstName); // alerts "person1 is Alice"

alert('person2 is ' + person2.firstName); // alerts "person2 is Bob"

The Methods

Methods follow the same logic as properties; the difference is that they are functions and they are defined as functions. Calling a method is similar to accessing a property, but you add () at the end of the method name, possibly with arguments. To define a method, assign a function to a named property of the class's prototype property; the name that the function is assigned to is the name that the method is called by on the object.

In the example below we define and use the method sayHello() for the Person class.

function Person(firstName) {

  this.firstName = firstName;

}

Person.prototype.sayHello = function() {

  alert("Hello, I'm " + this.firstName);

};

var person1 = new Person("Alice");

var person2 = new Person("Bob");

// call the Person sayHello method.

person1.sayHello(); // alerts "Hello, I'm Alice"

person2.sayHello(); // alerts "Hello, I'm Bob"

In JavaScript methods are regular function objects that are bound to an object as a property, which means they can be invoked "out of the context". Consider the following example code:

function Person(firstName) {

  this.firstName = firstName;

}

Person.prototype.sayHello = function() {

  alert("Hello, I'm " + this.firstName);

};

var person1 = new Person("Alice");

var person2 = new Person("Bob");

var helloFunction = person1.sayHello;

person1.sayHello();                                 // alerts "Hello, I'm Alice"

person2.sayHello();                                 // alerts "Hello, I'm Bob"

helloFunction();                                    // alerts "Hello, I'm undefined" (or fails

                                                    // with a TypeError in strict mode)

alert(helloFunction === person1.sayHello);          // alerts true

alert(helloFunction === Person.prototype.sayHello); // alerts true

helloFunction.call(person1);                        // alerts "Hello, I'm Alice"

As that example shows, all of the references we have to the sayHello function — the one on person1, on Person.prototype, in the helloFunctionvariable, etc. — refer to the same function. The value of this during a call to the function depends on how we call it. In the common case when we call it in an expression where we got the function from an object property — person1.sayHello() — this is set to the object we got the function from (person1), which is why person1.sayHello() uses the name "Alice" and person2.sayHello() uses the name "Bob". But if we call it other ways, this is set differently: Calling it from a variable — helloFunction() — sets this to the global object (window, on browsers). Since that object (probably) doesn't have a firstName property, we end up with "Hello, I'm undefined". (That's in loose mode code; it would be different [an error] in strict mode, but to avoid confusion we won't go into detail here.) Or we can set this explicitly using Function#call (or Function#apply), as shown at the end of the example.

See more about this on Function#call and Function#apply

Inheritance

Inheritance is a way to create a class as a specialized version of one or more classes (JavaScript only supports single inheritance). The specialized class is commonly called the child, and the other class is commonly called the parent. In JavaScript you do this by assigning an instance of the parent class to the child class, and then specializing it. In modern browsers you can also use Object.create to implement inheritance.

JavaScript does not detect the child class prototype.constructor see Core JavaScript 1.5 Reference:Global Objects:Object:prototype property, so we must state that manually.

In the example below, we define the class Student as a child class of Person. Then we redefine the sayHello() method and add the sayGoodBye()method.

// Define the Person constructor

function Person(firstName) {

  this.firstName = firstName;

}

// Add a couple of methods to Person.prototype

Person.prototype.walk = function(){

  alert("I am walking!");

};

Person.prototype.sayHello = function(){

  alert("Hello, I'm " + this.firstName);

};

// Define the Student constructor

function Student(firstName, subject) {

  // Call the parent constructor, making sure (using Function#call) that "this" is

  // set correctly during the call

  Person.call(this, firstName);

  // Initialize our Student-specific properties

  this.subject = subject;

};

// Create a Student.prototype object that inherits from Person.prototype.

// Note: A common error here is to use "new Person()" to create the Student.prototype.

// That's incorrect for several reasons, not least that we don't have anything to

// give Person for the "firstName" argument. The correct place to call Person is

// above, where we call it from Student.

Student.prototype = Object.create(Person.prototype); // See note below

// Set the "constructor" property to refer to Student

Student.prototype.constructor = Student;

// Replace the "sayHello" method

Student.prototype.sayHello = function(){

  alert("Hello, I'm " + this.firstName + ". I'm studying " + this.subject + ".");

};

// Add a "sayGoodBye" method

Student.prototype.sayGoodBye = function(){

  alert("Goodbye!");

};

// Example usage:

var student1 = new Student("Janet", "Applied Physics");

student1.sayHello();   // "Hello, I'm Janet. I'm studying Applied Physics."

student1.walk();       // "I am walking!"

student1.sayGoodBye(); // "Goodbye!"

// Check that instanceof works correctly

alert(student1 instanceof Person);  // true

alert(student1 instanceof Student); // true

Regarding the Student.prototype = Object.create(Person.prototype); line: On older JavaScript engines without Object.create, one can either use a "polyfill" (aka "shim", see the linked article), or one can use a function that achieves the same result, such as:

function createObject(proto) {

    function ctor() { }

    ctor.prototype = proto;

    return new ctor();

}

// Usage:

Student.prototype = createObject(Person.prototype);

See Object.create for more on what it does, and a shim for older engines.

Encapsulation

In the previous example, Student does not need to know how the Person class's walk() method is implemented, but still can use that method; theStudent class doesn't need to explicitly define that method unless we want to change it. This is called encapsulation, by which every class inherits the methods of its parent and only needs to define things it wishes to change.

Abstraction

Abstraction is a mechanism that permits modeling the current part of the working problem. This can be achieved by inheritance (specialization), or composition. JavaScript achieves specialization by inheritance, and composition by letting instances of classes be the values of attributes of other objects.

The JavaScript Function class inherits from the Object class (this demonstrates specialization of the model). and the Function.prototype property is an instance of Object (this demonstrates composition)

var foo = function(){};

alert( 'foo is a Function: ' + (foo instanceof Function) );                  // alerts "foo is a Function: true"

alert( 'foo.prototype is an Object: ' + (foo.prototype instanceof Object) ); // alerts "foo.prototype is an Object: true"

Polymorphism

Just like all methods and properties are defined inside the prototype property, different classes can define methods with the same name; methods are scoped to the class in which they're defined. This is only true when the two classes do not hold a parent-child relation (when one does not inherit from the other in a chain of inheritance).

Notes

The techniques presented in this article to implement object-oriented programming are not the only ones that can be used in JavaScript, which is very flexible in terms of how object-oriented programming can be performed.

Similarly, the techniques shown here do not use any language hacks, nor do they mimic other languages' object theory implementations.

There are other techniques that make even more advanced object-oriented programming in JavaScript, but those are beyond the scope of this introductory article.

References

Mozilla. "Core JavaScript 1.5 Guide", https://developer.mozilla.org/docs/Web/JavaScript/Guide
Wikipedia. "Object-oriented programming", http://en.wikipedia.org/wiki/Object-...ed_programming
OOP JavaScript Overview series by Kyle Simpson

Document Tags and Contributors

Tags:

Contributors to this page: groovecoder, coralynus2, actionscript, abacon, jswisher, Jeremie, pneftali, Hamstersoup, Trasvina, Entro, Fannynoble, Shawneec, callmefool,Sevenspade, jeffozvold, erikvold, inma_610, tjcrowder, Aurangzaib, sriramr, BrianDiPalma, montogeek, yuval, Sheppy, lavish, njbair, DavidWalsh, dybskiy, Nickolay, alokmenghrajani,godu, Steve_Fenton, OsvaldoGago, Waldo, FernandoBasso, raztus, anbinhtrong, evert, dpickett, inglor, BYK, BenB, nishs, encounter

Last updated by: montogeek, Jul 17, 2014 11:24:17 AM