adding few prototype related problems and explanation

Author: rohan-paul

Javascript/Prototypal-Inheritence/Prototype-func-String-dasherize.js

@@ -0,0 +1,9 @@
+// Extending Native Constructors.  This is often considered a bad practice because if you create a custom String method and browsers in the future implement that method slightly differently, code may not work as you’d expect. Despite that, it is still a good exercise and worthwhile to learn for understanding prototypes.
+
+// Write a function to replace a single space with a "-"
+
+String.prototype.dasherize = function() {
+    return this.replace(/\s/g, '-')
+}
+
+console.log('Hello world'.dasherize());

Javascript/Prototypal-Inheritence/getPrototypesOf-Basics.js

@@ -0,0 +1,28 @@
+/* Every JavaScript object has an internal property called [[Prototype]]. If you look up a property via obj.propName or obj['propName'] and the object does not have such a property - which can be checked via obj.hasOwnProperty('propName') - the runtime looks up the property in the object referenced by [[Prototype]] instead. If the prototype-object also doesn't have such a property, its prototype is checked i */
+
+// basic way to print a given array's prototypes
+
+let myArr = [1, 2, 3];
+
+// console.log(Object.getPrototypeOf(myArr)) // => []
+
+// console.log(Object.getOwnPropertyNames(myArr))  // => [ '0', '1', '2', 'length' ]
+
+// Not a prototype method, but you can use Object.getPrototypeOf to traverse the prototype chain and then get the own property names of each of those objects.
+
+console.log(Object.getPrototypeOf(Array.prototype))  // => {}
+
+/* The prototype relations of JavaScript objects form a tree-shaped struc-
+ture, and at the root of this structure sits Object.prototype. It provides a few
+methods that show up in all objects, such as toString, which converts an ob-
+ject to a string representation.  */
+
+console.log(Object.prototype)  // => {}
+
+/* Many objects don’t directly have Object.prototype as their prototype, but
+instead have another object, which provides its own default properties. Func-
+tions derive from Function.prototype, and arrays derive from Array.prototype.  */
+
+console.log(Object.getPrototypeOf(isNaN) === Function.prototype)  // => true  as both will return [Function]
+
+console.log(Object.getPrototypeOf([]))  // = []

Javascript/Prototypal-Inheritence/print-All-Prototypes-of-Objects.js

@@ -0,0 +1,56 @@
+// Write a function to list Down All Prototype Properties of an Javascript Object
+
+printPrototypeProperties = obj => {
+    var result = [];
+
+    let objProp = Object.getOwnPropertyNames(obj)
+    console.log(objProp)
+
+    // console.log(Object.keys(obj))
+
+    for (let i of objProp) {
+
+      if (result.indexOf(i) === -1 ) {
+        result.push(i);
+      }
+    }
+    return result;
+  }
+
+
+let myObj = {
+	"a": 1,
+	"b": 2,
+    "c": 3
+}
+
+console.log(printPrototypeProperties(myObj));
+
+
+/* Object.getOwnPropertyNames vs Object.keys
+
+https://stackoverflow.com/questions/22658488/object-getownpropertynames-vs-object-keys
+
+
+203
+down vote
+accepted
+There is a little difference. Object.getOwnPropertyNames(a) returns all own properties of the object a. Object.keys(a) returns all enumerable own properties. It means that if you define your object properties without making some of them enumerable: false these two methods will give you the same result.
+
+It's easy to test:
+
+var a = {};
+Object.defineProperties(a, {
+    one: {enumerable: true, value: 'one'},
+    two: {enumerable: false, value: 'two'},
+});
+
+Object.keys(a); // ["one"]
+Object.getOwnPropertyNames(a); // ["one", "two"]
+
+If you define a property without providing property attributes descriptor (meaning you don't use Object.defineProperties), for example:
+
+a.test = 21;
+then such property becomes an enumerable automatically and both methods produce the same array.
+
+*/

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

@@ -0,0 +1,25 @@
+// 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
+Array.prototype.print = function() {
+    let resultArr = []
+    this.forEach(i => resultArr.push(i))
+    return console.log(resultArr.join());
+}
+
+myArr = [1, 2, 3]
+myArr.print()  // => 1,2,3
+
+// SOL-2
+Array.prototype.print_1 = function() {
+    return this.forEach(i => console.log(i))
+}
+
+
+myArr.print_1()
+
+/* OUTPUT
+1
+2
+3 */