JavaScript is one of the most popular languages used by programmers all around the world. In this course, you'll be introduced to the Object-Oriented Paradigm of JavaScript. The course will discuss OOP in both, ES5 and ES6 versions of JavaScript. It begins with a basic introduction to what Object-Oriented programming is, followed by its comparison to other languages. It then introduces the new  OOP features available in ES6 version and compares it to the ES5 version. The course then discusses objects in JavaScript followed by the use of function as objects in OOP. It goes over the interesting concepts of prototype objects, data encapsulation, and classes. It then delves into the more complex concepts of inheritance in both the versions, including prototypal inheritance, prototype chaining, method overriding and mixins. The course is filled with interesting illustrations to help in your understanding of the concepts as well as numerous quizzes and exercises to help you practice.

Learn Object-Oriented Programming in JavaScript

In the [previous](https://www.educative.io/collection/page/5429798910296064/5907042445295616/5684715073830912) lesson, we asked the question regarding whether there was a simpler approach for adding new methods/properties to a constructor function. This introduces us to the very major concept of **"Prototype Objects"** in Javascript.

Before we get into how it can be used, let’s discuss what a *prototype* is.

# Prototype Properties in Objects

Instead of jumping directly into the definition, let’s begin by looking at the code below:

//creating an constructor function  named EmployeeConstructor
function EmployeeConstructor(_name,_age,_designation) {
   this.name = _name,
   this.age = _age,
   this.designation = _designation
}
//creating an object from EmployeeConstructor using "new" keyword
//The object created is stored in the variable employeeObj
var employeeObj = new EmployeeConstructor('Joe',22,'Developer')
console.log(employeeObj)

As seen above, if we display `employeeObj` the three properties: `name`, `age` and `designation` are displayed, encapsulated inside the `EmployeeConstructor` object created when the `new` command is used, along with their values.

If the same code is run locally on the browser, the browser console will display the following:

Notice anything different? Apart from `age`, `designation` and `name`, there is an additional property inside the `EmployeeConstructor` object created. This is known as the `[[Prototype]]` property of that object. It is a hidden property that is present inside every object created from a constructor function. 

# Prototype Object

So far we know the following:

* Any object instance created from a *constructor function* has a hidden property.

* This hidden property is called the `[[Prototype]]` property of the object.

Just like objects whenever a *constructor function* is initialized, it also gets a `[[Prototype]]` property assigned to it. 

The `[[Prototype]]` property of a *constructor function* is an **object** itself containing further properties hence, it is also known as a **Prototype Object**.


At this point, you should know that the `[[Prototype]]` property of an object instance, `employeeObj` in our case, always points to the **Prototype Object** of the *constructor function* from which it was created, `EmployeeConstructor` in our case.

>**Note:** The prototype property in **Prototype Object**  points to `null`.



This lesson explains the prototype objects, what they are, how they are accessed and why they are used to add properties.