refactor: oops

Author: brijeshkumar-chavda

28_object_oriented_programming/1_object.js

@@ -3,6 +3,10 @@
 // What
 // - It is collection of properties and method.
 
+// Why
+// - We need object to store data in proper way.
+// - It is like creating box/ container to store the specific item inside it. So it easy to access them.
+
 // Example
 // - In JavaScript there is Object Literal {}.
 // - This means we are declaring literally an object.
@@ -16,8 +20,3 @@ const object = {
     console.log(parameter);
   },
 };
-
-// Why we need object?
-// - We need object to store data in proper way.
-// - It is like creating box/ container to store the specific item inside it. So it easy to access them.
-

28_object_oriented_programming/2_current_contex.js

@@ -1,4 +1,6 @@
 // Context/ Current Context
+
+// What
 // - When you are talking with your friend about some event that is host on MONDAY.
 // - But you need to also clearly mention that which MONDAY are you talking about it was last week, current week or upcoming week.
 // - This is the same for `this` keyword. It help to find the current context.

28_object_oriented_programming/2_constructor_function.js 28_object_oriented_programming/3_constructor_function.js

@@ -1,6 +1,10 @@
 // Constructor Function
 
-// What is Construction Function?
+// Backstory
+// - In other programming language like C++ and Java.
+// - We have to create a class then inside the class we need to declare constructor after that we can create an object (Instance/ Instance Object).
+
+// What
 // - Yes, in JavaScript, you can create constructor functions without using the class keyword or the constructor keyword. Instead, you can define a regular function and manually assign properties and methods to the newly created object using the this keyword.
 
 function ConstructorFunction(parameter1, parameter2) {
@@ -17,7 +21,5 @@ function ConstructorFunction(parameter1, parameter2) {
 }
 
 // Creating new instance
-const object = new ConstructorFunction("value1", "value2");
-// console.log(object);
-
-
+const instanceObject = new ConstructorFunction("argument1", "argument2");
+console.log(instanceObject);

28_object_oriented_programming/3_new_keyword.js 28_object_oriented_programming/4_new_keyword.js

@@ -1,9 +1,11 @@
 // `new` Keyword
 
-// What is `new` Keyword?
+// Object === Instance === Instance Object
+
+// What
 // - In JavaScript, the new keyword is used to create an instance of an object or to invoke a constructor function.
 
-// Why we need `new` keyword?
+// Why
 // - If you create a new instance without the `new` keyword it will update the value of previously created instance.
 
 // How the `new` keyword work?
@@ -14,7 +16,7 @@
 // 2. Binds the newly created object as the `this` keyword within the constructor function.
 // - Sets the prototype of the newly created object to the prototype property of the constructor function.
 // - Executes the constructor function, which initializes the newly created object with properties and methods.
-// - Returns the newly created object.  
+// - Returns the newly created object.
 
 function User(username, userID, userEmail) {
   this.username = username;
@@ -27,6 +29,7 @@ function User(username, userID, userEmail) {
   return this;
 }
 
+// Try this without `new` keyword
 const userOne = new User("user1", "123", "[email protected]");
 const userTwo = new User("user2", "456", "[email protected]");
 

28_object_oriented_programming/4_prototype.js 28_object_oriented_programming/5_prototype.js

@@ -1,16 +1,13 @@
 // Prototype (Better to call Prototype Object)
 
-// Inheritance: In JavaScript is a mechanism that allows one object to acquire properties and methods of another object. This is primarily achieved through the prototype chain.
+// What
+
+// Inheritance: In JavaScript is a mechanism that allows one object to acquire properties and methods of another object.
 
 // Prototype: In JavaScript, objects have a special hidden property [[Prototype]] (as named in the specification), that is either null or references another object. That object is called “a prototype”:
 
 // Prototype Inheritance: When we read a property from object, and it’s missing, JavaScript automatically takes it from the prototype. In programming, this is called “prototypal inheritance”.
 
-// What
-// - Prototype is object.
-// - Other objects inherit properties and methods from the prototype.
-// - Every object in JavaScript has a prototype.
-
 // Why
 // - The prototype system allows JavaScript to implement inheritance and to share properties and methods across instances.
 // - This makes code reuse and object - oriented programming possible in JavaScript.
@@ -22,22 +19,22 @@
 // - Yes, function is function.
 // - In JavaScript everything is object.
 
-function regularFunction(parameter) {
+function ConstructorFunction(parameter) {
   console.log(parameter);
 }
 
 // Normally calling function
-console.log(regularFunction("argument"));
+console.log(ConstructorFunction("argument"));
 
 // Adding property into function like an object
-regularFunction.power = 2;
-console.log(regularFunction.power);
+ConstructorFunction.power = 2;
+console.log(ConstructorFunction.power);
 
 // Prototype in function
-console.log(regularFunction.prototype);
+console.log(ConstructorFunction.prototype);
 
 // Note
-// - Every object in JavaScript inherit properties and method of parent object. It continues.
+// - Every object in JavaScript inherit properties and method of parent object. It's continues process.
 // Object <- (Prototype + Inheriting) <- Parent Object <- (Prototype + Inheriting) <- Grand Parent Object
 
 // Array <- (Prototype + Inheriting) <- Object <- .length
@@ -48,17 +45,18 @@ console.log(regularFunction.prototype);
 
 // - If you wondering what will you get at the end of this prototype inheritance chain is `null`.
 
-function regularFunction(parameter) {
+// Constructor Function + Prototype + `new` keyword
+function ConstructorFunction(parameter) {
   this.parameter = parameter;
 }
 
-regularFunction.prototype.method = function () {
+ConstructorFunction.prototype.method = function () {
   this.parameter++;
 };
 
-regularFunction.prototype.printMethod = function () {
+ConstructorFunction.prototype.printMethod = function () {
   console.log(this.parameter);
 };
 
-const object1 = new regularFunction("argument");
-const object2 = new regularFunction("argument");
+const instanceObject1 = new ConstructorFunction("argument");
+const instanceObject2 = new ConstructorFunction("argument");