checking prototype of an object

Author: rohan-paul

Javascript/OOP-Prototypal-Inheritence/how-to-get-prototype-of-an-object.md

@@ -0,0 +1,53 @@
+The below is also an example of what 'this' refers to when I define a constructor function with new keyword. HERE, `this` will refer to an object that inherits from `instance.prototype`
+
+Here,
+
+```js
+function Person(first, last) {
+  this.first = first
+  this.last = last
+
+  this.displayName = function() {
+    console.log(`Full name : ${this.first} ${this.last}`)
+  }
+}
+
+// Note in above, I can not use arrow function as I can not create a constructor function with arrow syntax
+
+let person1 = new Person("John", "Reed")
+let person2 = new Person("Rohan", "Paul")
+
+person1.displayName() // Full name : John Reed
+person2.displayName() // Full name : Rohan Paul
+```
+
+So to know the prototype of the instance
+
+```js
+console.log(person1.prototype) // undefined
+
+Object.getPrototypeOf(person1) // Person {}
+
+person1.__proto__ // Person {}
+```
+
+Another example
+
+```js
+function Student() {
+  this.name = "John"
+  this.gender = "M"
+}
+
+var studObj = new Student()
+
+console.log(Student.prototype) // Student {}
+console.log(studObj.prototype) // undefined
+console.log(studObj.__proto__) // Student {}
+console.log(Object.getPrototypeOf(studObj)) // Student {}
+
+console.log(typeof Student.prototype) // object
+console.log(typeof studObj.__proto__) // object
+
+console.log(Student.prototype === studObj.__proto__) // true
+```

Javascript/OOP-Prototypal-Inheritence/prototype-func-print-array-elements.js

@@ -1,25 +1,24 @@
 // https://youtu.be/OOC-ypVnHAY?t=10m35s - That Indian looking guy, who takes mock interview in YT.
 // Problem - write a function print() which will be implemented like this myArr.print()  and it will print all the elements of the array
 
-// SOL-1
+// SOL-1 - Not a good solution as I dont need the extra step of pushing to the resultArr
 Array.prototype.print = function() {
-    let resultArr = []
-    this.forEach(i => resultArr.push(i))
-    return console.log(resultArr.join());
+  let resultArr = []
+  this.forEach(i => resultArr.push(i))
+  return console.log(resultArr.join())
 }
 
 myArr = [1, 2, 3]
-myArr.print()  // => 1,2,3
+myArr.print() // => 1,2,3
 
 // SOL-2
 Array.prototype.print_1 = function() {
-    return this.forEach(i => console.log(i))
+  return this.forEach(i => console.log(i))
 }
 
-
 myArr.print_1()
 
 /* OUTPUT
 1
 2
-3 */
+3 */

Javascript/js-basics/this-keyword.js renamed to Javascript/js-basics/this-keyword-1.js

@@ -32,7 +32,15 @@ function f2() {
 
 f2() === undefined // true
 
-/* Now the case when “this” Refers to a New Instance
+/* Now the case when “this” Refers to a New Instance - HERE, `this` will refer to an object that inherits from `instance.prototype` . Meaning with exact JS syntax
+
+Object.getPrototypeOf(instance)
+
+OR
+
+instance.__proto__
+
+( I can print the above 2 expression to get the prototype of the instance)
 
 When a function is invoked with the new keyword, then the function is known as a constructor function and returns a new instance. In such cases, the value of this refers to a newly created instance.
 For example: */
@@ -54,7 +62,17 @@ let person2 = new Person("Rohan", "Paul")
 person1.displayName() // Full name : John Reed
 person2.displayName() // Full name : Rohan Paul
 
-/* In the case of person.displayName, this refers to a new instance person, and in case of person2.displayName(), this refers to person2 (which is a different instance than Person).  */
+/* In the case of person1.displayName, this refers to a new instance of person1, and in case of person2.displayName(), this refers to person2 (which is a different instance than Person).
+
+I can check what the the prototype object of person1 with below
+
+console.log(person1.prototype) // undefined
+
+Object.getPrototypeOf(person1) // Person {}
+
+person1.__proto__ // Person {}
+
+*/
 
 // NOW AS A SIDE POINT - To pass the value of this from one context to another, use call(), or apply():
 

Javascript/js-basics/this-keyword-simples-examples.md

@@ -24,9 +24,18 @@ The crux of the problem is that numbers are represented in this format as a whol
 
 For 0.1 in the standard binary64 format, the representation can be written exactly as
 
+```
 0.1000000000000000055511151231257827021181583404541015625 in decimal, or
 0x1.999999999999ap-4 in C99 hexfloat notation.
+
+```
+
 In contrast, the rational number 0.1, which is 1/10, can be written exactly as
 
+```
 0.1 in decimal, or
-0x1.99999999999999...p-4 in an analogue of C99 hexfloat notation, where the ... represents an unending sequence of 9's.
+0x1.99999999999999...p-4
+
+```
+
+in an analogue of C99 hexfloat notation, where the ... represents an unending sequence of 9's.