The Object.assign() method is used to copy the properties and values from one or more source objects to a target object. It returns the target object. When objects are assigned or copied using Object.assign(), they are assigned or copied by reference, meaning that the target object and the source object refer to the same underlying object in memory.

The Object.create() method is used to create a new object with the specified properties. It is a way of creating a new object using an existing object as the prototype. The Object.create() method accepts two arguments: the prototype object and an optional property descriptor object.

The prototype object is the object that the newly created object will inherit from. The property descriptor object is optional and can be used to specify the characteristics of the properties to be added to the new object.

For example:

The Object.defineProperty() method is used to define a new property on an object, or to modify an existing property on an object. It returns the object. Both Object.defineProperty() and Object.defineProperties() can be used to define new properties on an object.

The Object.defineProperties() method is a predefined function in the object library of JavaScript that is used to define new properties or modify existing properties on an object. It returns the object.
The Object.defineProperties() method takes an object as its first argument and a property descriptor object as its second argument. The property descriptor object can specify the characteristics of one or more properties to be added to or modified on the object.

"The Dojo toolkit and Google's Closure library both have functions called provide() and require() that are used for declaring and loading modules."

In JavaScript, inheritance is implemented using prototypes, which are objects that serve as templates for creating other objects. When an object is created, it inherits properties and methods from its prototype, which can be another object or null. This is known as prototype-based inheritance.
One of the characteristics of prototype-based inheritance in JavaScript is that it is dynamic. This means that the prototype of an object can be changed at any time, and the changes will be reflected in all objects that inherit from it.
This is different from classical inheritance in languages like Java, where the inheritance hierarchy is fixed at the time the object is created and cannot be changed later.
In JavaScript, we can augment a class (which is implemented as a constructor function) by adding new methods to its prototype object.
For example: function Person(name) {
this.name = name;
}

Person.prototype.sayHello = function() {
console.log(`Hello, my name is ${this.name}`);
}

const person = new Person('Alice');
person.sayHello(); // Output: "Hello, my name is Alice"
Here, we define a Person constructor function that takes a name parameter and assigns it to the name property of the object being created.
We then add a sayHello method to the Person prototype object. When we create a new Person object using the new keyword, the object inherits the sayHello method from its prototype, so we can call it on the object.

In object-oriented programming, the this keyword is used to refer to the current object. It is commonly used inside the body of a class's methods to refer to the object on which the method is being called.

For example, consider the following class:

class Person { constructor(name) {
this.name = name;
}

sayHello() {
console.log(`Hello, my name is ${this.name}`);
}
}


Here, the Person class has a constructor function that takes a name parameter and assigns it to the name property of the object being created.
The class also has a method called sayHello that prints a greeting to the console using the name property of the object.

In object-oriented programming, a constructor is a special method that is used to create and initialize an object created from a class.

In the example you provided, the Person class has a constructor function defined with the constructor keyword.
The constructor function takes a name parameter and assigns it to the name property of the object being created.

An object can be created from a class using the new keyword, followed by the name of the class and parentheses.
When an object is created using the new keyword, the class's constructor function is automatically called to initialize the object.
For example:
const person1 = new Person('Alice');
const person2 = new Person('Bob');
Here, two objects are created from the Person class using the new keyword. This causes the class's constructor function to be called twice, once for each object, initializing each object with its own name property.
So in this example, both statements const person1 = new Person('Alice'); and const person2 = new Person('Bob'); create an instance of the Person class, also known as an object

The emp function is defined as a constructor function that takes two arguments: name and salary.
The name and salary properties of the object are set using the this keyword.
The changeSalary method is defined and assigned to the changeSalary property of the object using the this keyword. The changeSalary method takes a single argument: otherSalary.
An object is created using the emp constructor function and passing it the arguments "Rahul" and 30000. 
This creates an object with the name property set to "Rahul" and the salary property set to 30000.
The changeSalary method is called on the object, passing it the argument 45000. This sets the salary property of the object to 45000.
The name and salary properties of the object are written to the document using the document.write() method. The output is e.name+ 45000.


The changeSalary method uses the this keyword to refer to the current object and sets the salary property of the object to the value of the otherSalary argument. 
This allows you to change the salary of the object by calling the changeSalary method and passing it a new salary value

It is possible to add methods to the Object.prototype object in JavaScript, which makes them available on all objects. This can be done using the Object.defineProperty() method or by assigning a new property directly to the Object.prototype object.