#constructor function

New Post has been published on https://www.codesolutionstuff.com/javascript-program-to-create-objects-in-different-ways/

JavaScript Program to Create Objects in Different Ways

Summary

Inheritance in JavaScript is when an object is based on another object. Inheritance allows us to reuse existing code, having objects take on properties of other objects.

When a function is called as a constructor using the new operator, the function creates and returns a new object. This object is secretly linked to its constructor's prototype, which is just another object. Using this secret link allows an object to access the prototype's properties and methods as if it were its own. If JavaScript does not find a particular property within an object, it will keep looking up the prototype chain, eventually reaching Object() (top-level parent) if necessary.

We also looked at a few methods and properties that allow use to check the origins and references of objects and their prototypes, namely:

hasOwnProperty()

isPrototypeOf()

Object.getPrototypeOf()

JavaScript is an extremely flexible object-oriented language that has evolved over time. Functionality from the past lives side by side with new functionality that is being added on a daily basis.

Part of that flexibility means you get options. Below I discuss two ways that you can define and instantiate an object in JavaScript!

1. Using Constructor Functions

The most common method for constructing object is through a combination of a function and the keyword new. Below is a simple example:

var Cat = function(name, color){ this.name = name; this.color = color; // methods can be added to the object here // however it is not recommended -- see below! this.meow = function() { console.log("meow!"); }; };

Once the object has been defined, you can call a constructor function to instantiate each Cat.

var cat1 = new Cat('Garfield', 'orange'); cat1.meow(); // logs "meow!" to the console

As mentioned above, the function meow can be defined within our definition of Cat. However, this is not the recommended approach. Instead, it is almost always preferable to add the object's methods to the object's prototype instead.

Each cat-instance doesn't need its own methods saved in memory. Instead, methods can be stored to the Cat object's prototype -- in a single location which is accessible to all instances of cat. Wherever possible use this inexpensive approach instead:

Cat.prototype.meow = function() { console.log("meow!"); };

2. Using Object Literals

Using object literals, you can skip the class definition and constructor function entirely and skip directly to creating an instance of your desired object. The below code instantiates code identical to the above quickly and effortlessly:

var cat1 = { name: "Garfield", color: "Orange", meow: function(){ console.log("meow!"); } };

This may be a desirable approach where you only need a single instance of the object -- singletons!