Learn OOJS in 30 minute

Object-oriented to the core, JavaScript features powerful, flexible OOP capabilities.

Object-oriented programming

Object-oriented programming (OOP) is a programming paradigm that uses abstraction to create models based on the real world. OOP 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 OOP.

OOP promotes greater flexibility and maintainability in programming, and is widely popular in large-scale software engineering. Because OOP strongly emphasizes modularity, object-oriented code is simpler to develop and easier to understand later on. Object-oriented code promotes more direct analysis, coding, and understanding of complex situations and procedures than less modular programming techniques


A container which lets developers bundle all functionality under a unique, application-specific name.

// global namespace
var ABC = ABC || {};
The following is code syntax for creating a namespace and adding variables, functions, and a method:

// Create container called MYAPP.commonMethod for common method and properties
ABC.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
ABC.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 addListener method:
ABC.event.addListener("yourel", "type", callback);
Defines the object’s characteristics. A class is a template definition of an object’s properties and methods.
JavaScript is a prototype-based language and contains no class statement, such as is found in C++ or Java. This is sometimes confusing for programmers accustomed to languages with aclass statement. Instead, JavaScript uses functions as constructors for classes. Defining a class is as easy as defining a function. In the example below we define a new class called Person with an empty constructor.

//create class
var Person = function () {};

var person1 = new Person();
var person2 = new Person();
An instance of a class.
An object characteristic, such as color.
An object capability, such as walk. It is a subroutine or function associated with a class.

var Person = function (firstName) {
  this.firstName = firstName;

Person.prototype.sayHello = function() {
  console.log("Hello, I'm " + this.firstName);

var person1 = new Person("Alice");
var person2 = new Person("Bob");

// call the Person sayHello method.
person1.sayHello(); // logs "Hello, I'm Alice"
person2.sayHello(); // logs "Hello, I'm Bob"
A method called at the moment an object is instantiated. It usually has the same name as the class containing it.
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.
A class can inherit characteristics and capabilities from another class.
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.

// Define the Person constructor
var Person = function(firstName) {
  this.firstName = firstName;

// Add a couple of methods to Person.prototype
Person.prototype.walk = function(){
  console.log("I am walking!");

Person.prototype.sayHello = function(){
  console.log("Hello, I'm " + this.firstName);

// Define the Student constructor
function Student(firstName, subject) {
  // Call the parent constructor, making sure (using 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(){
  console.log("Hello, I'm " + this.firstName + ". I'm studying "
              + this.subject + ".");

// Add a "sayGoodBye" method
Student.prototype.sayGoodBye = function(){

// 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
console.log(student1 instanceof Person);  // true 
console.log(student1 instanceof Student); // true
A technique which involves bundling the data and the methods that use the data together.
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; the Student class doesn’t need to explicitly define that method unless we want to change it. This is called encapsulation
The conjunction of an object’s complex inheritance, methods, and properties to adequately reflect a reality model.
Abstraction is a mechanism that allows you to model the current part of the working problem, either by inheritance (specialization) or composition. JavaScript achieves specialization by inheritance, and composition by letting class instances be the values of other objects’ attributes.
Poly means “many” and morphism means “forms“. Different classes might define the same method or property.
Just as 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, unless the two classes hold a parent-child relation (i.e. one inherits from the other in a chain of inheritance).