In JavaScript, almost everything behaves like an object due to its prototype, except for primitives (numbers, booleans, strings, null, and undefined). Objects are used to group variables that belong together and are organized using key-value pairs. They can also be used to create complex applications through object-oriented programming, where objects interact with each other through properties and methods.

One way to create objects in JavaScript is through a function constructor, which allows you to create multiple objects (instances) from a single blueprint. To do this, you can create a function and attach the arguments to the this variable of the function execution context:

var Person = function(name, birth, job) {
  this.name = name;
  this.birth = birth;
  this.job = job;
};

Then, you can use the new operator to create a new object and pass in your arguments to the function:

var joseph = new Person('joseph', 1990, 'designer');

This is called instantiation because the new object is created off the constructor and is an instance of it.

To understand how all of these work, it's important to understand what the new operator does. When you use the new operator, it creates a brand new empty object and then calls the function constructor (in this case, Person) with the this variable pointing to the new object, rather than the global object. Then, when the code inside the function runs:

this.name = name;
this.birth = birth;
this.job = job;

the properties name, birth, and job are set on the new object, which is then assigned to the joseph variable.

Inheritance

Inheritance is when one object has access to another object's methods and properties. In JavaScript, you can use the prototype property to create inheritance. Every object has a prototype property, which points to another object. When you try to access a property or method of an object, the JavaScript engine will first look for it on the object itself. If it can't find it there, it will look for it on the object's prototype, and so on until it reaches the end of the prototype chain. This allows you to create a base object with shared properties and methods that can be inherited by other objects.

You can also use the Object.create() method to create inheritance, which allows you to specify the object that should be the prototype of the new object you are creating.

summary

understanding how objects, function constructors, and inheritance work in JavaScript is important for creating complex applications