Gain insights into writing cleaner, modular, scalable JavaScript code through OOP. Explore basics to advanced concepts like prototypal inheritance, method overriding, and ES6 features.

Learn to write cleaner, more modular, and more scalable code in JavaScript by gaining mastery of Object Oriented Programming (OOP). 

You'll start with the basics of object-oriented programming and build up to more advanced concepts such as prototypal inheritance, prototype chaining, method overriding and mixins. Along the way, you'll learn how each concept applies to JavaScript's sometimes unique way of handling things. You'll also see how various JavaScript features make it particularly convenient for OOP, with particular emphasis on changes introduced in ES6.

This course is filled with hands-on coding challenges, playgrounds, snippets, and illustrations to keep things interactive.

Learn Object-Oriented Programming in JavaScript

In this lesson, we will learn about the 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 along with their values, encapsulated within the `EmployeeConstructor` object, which was created using `new`.

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 created inside the `EmployeeConstructor` object. 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 prototype objects, what they are, how they are accessed, and why they are used to add properties.

Introduction

Objects in JavaScript

Functions as Objects

OOP in JS - Exam 1

Classes

Inheritance

OOP in JS - Exam 2

Prototype Objects

Prototype Properties in Objects