updated

Author: ps0305

Object Oriented Programming/15 Understand Where an Object’s Prototype Comes From.js

@@ -0,0 +1,23 @@
+Just like people inherit genes from their parents, an object inherits its prototype directly from the constructor function that created it. For example, here the `Bird` constructor creates the `duck` object:
+```js
+function Bird(name) {
+  this.name = name;
+}
+
+let duck = new Bird("Donald");
+```
+duck inherits its prototype from the Bird constructor function. You can show this relationship with the `isPrototypeOf` method:
+```js
+Bird.prototype.isPrototypeOf(duck);
+// returns true
+```
+Use `isPrototypeOf` to check the prototype of beagle.
+```js
+function Dog(name) {
+  this.name = name;
+}
+
+let beagle = new Dog("Snoopy");
+
+// Add your code below this line
+Dog.prototype.isPrototypeOf(beagle);

Object Oriented Programming/15 Understand Where an Object’s Prototype Comes From.md

@@ -0,0 +1,27 @@
+All objects in JavaScript (with a few exceptions) have a prototype. 
+Also, an object’s prototype itself is an object.
+```js
+function Bird(name) {
+  this.name = name;
+}
+
+typeof Bird.prototype; // => object
+```
+Because a `prototype` is an object, a prototype can have its own prototype! 
+In this case, the prototype of `Bird.prototype` is `Object.prototype`:
+```js
+Object.prototype.isPrototypeOf(Bird.prototype);
+// returns true
+// How is this useful? You may recall the hasOwnProperty method from a previous challenge:
+
+let duck = new Bird("Donald");
+duck.hasOwnProperty("name"); // => true
+```
+The hasOwnProperty method is defined in Object.prototype, which can be accessed by `Bird.prototype`, which can then be accessed by duck. 
+This is an example of the prototype chain.
+
+In this prototype chain, `Bird` is the `supertype` for `duck`, while `duck` is the `subtype`. 
+`Object` is a `supertype` for both `Bird` and `duck`.
+
+`Object` is a `supertype` for `all objects` in `JavaScript`. 
+Therefore, any object can use the `hasOwnProperty` method.

Object Oriented Programming/16 Understand the Prototype Chain.js

@@ -1,9 +1,9 @@
-/*There's a principle in programming called Don't Repeat Yourself (DRY).
+There's a principle in programming called `Don't Repeat Yourself (DRY).`
 The reason repeated code is a problem is because any change requires fixing code in multiple places.
 This usually means more work for programmers and more room for errors.
 
-Notice in the example below that the describe method is shared by Bird and Dog:
-
+Notice in the example below that the describe method is shared by `Bird` and `Dog`:
+```js
 Bird.prototype = {
   constructor: Bird,
   describe: function() {
@@ -17,9 +17,10 @@ Dog.prototype = {
     console.log("My name is " + this.name);
   }
 };
+```
 The describe method is repeated in two places. 
-The code can be edited to follow the DRY principle by creating a supertype (or parent) called Animal:
-
+The code can be edited to follow the `DRY` principle by creating a `supertype` (or parent) called Animal:
+```js
 function Animal() { };
 
 Animal.prototype = {
@@ -28,18 +29,20 @@ Animal.prototype = {
     console.log("My name is " + this.name);
   }
 };
-Since Animal includes the describe method, you can remove it from Bird and Dog:
-
+```
+Since `Animal` includes the describe method, you can remove it from `Bird` and `Dog`:
+```js
 Bird.prototype = {
   constructor: Bird
 };
 
 Dog.prototype = {
   constructor: Dog
 };
-
-The eat method is repeated in both Cat and Bear. 
-Edit the code in the spirit of DRY by moving the eat method to the Animal supertype.*/
+```
+The eat method is repeated in both `Cat` and `Bear`. 
+Edit the code in the spirit of `DRY` by moving the eat method to the `Animal` `supertype`.
+```js
 function Cat(name) {
   this.name = name; 
 }

Object Oriented Programming/16 Understand the Prototype Chain.md

@@ -0,0 +1,42 @@
+In the previous challenge, you created a `supertype` called `Animal` that defined behaviors shared by all animals:
+```js
+function Animal() { }
+Animal.prototype.eat = function() {
+  console.log("nom nom nom");
+};
+```
+This and the next challenge will cover how to reuse Animal's methods inside `Bird` and `Dog` without defining them again. It uses a technique called `inheritance`.
+
+This challenge covers the first step: make an instance of the `supertype` (or parent).
+
+You already know one way to create an instance of `Animal` using the new operator:
+```js
+let animal = new Animal();
+```
+There are some `disadvantages` when using this syntax for inheritance, which are too complex for the scope of this challenge. Instead, here's an alternative approach without those disadvantages:
+```js
+let animal = Object.create(Animal.prototype);
+```
+`Object.create(obj)` creates a new object, and sets obj as the new object's prototype. Recall that the prototype is like the "recipe" for creating an object. By setting the prototype of animal to be `Animal's` prototype, you are effectively giving the animal instance the same "recipe" as any other instance of `Animal`.
+```js
+animal.eat(); // prints "nom nom nom"
+animal instanceof Animal; // => true
+```
+Use `Object.create` to make two instances of `Animal` named `duck` and `beagle`.*/
+```js
+function Animal() { }
+
+Animal.prototype = {
+  constructor: Animal, 
+  eat: function() {
+    console.log("nom nom nom");
+  }
+};
+
+// Add your code below this line
+
+let duck = Object.create(Animal.prototype); // Change this line
+let beagle = Object.create(Animal.prototype); // Change this line
+
+duck.eat(); // Should print "nom nom nom"
+beagle.eat(); // Should print "nom nom nom" 

Object Oriented Programming/17 Use Inheritance So You Don't Repeat Yourself.js renamed to Object Oriented Programming/17 Use Inheritance So You Don't Repeat Yourself.md

@@ -1,17 +1,18 @@
-/*In the previous challenge you saw the first step for inheriting behavior from the supertype (or parent) Animal: making a new instance of Animal.
-
-This challenge covers the next step: set the prototype of the subtype (or child)—in this case, Bird—to be an instance of Animal.
+In the previous challenge you saw the first step for inheriting behavior from the `supertype` (or parent) Animal: making a new instance of `Animal`.
 
+This challenge covers the next step: set the prototype of the subtype (or child)—in this case, `Bird—to` be an instance of `Animal`.
+```js
 Bird.prototype = Object.create(Animal.prototype);
-Remember that the prototype is like the "recipe" for creating an object. In a way, the recipe for Bird now includes all the key "ingredients" from Animal.
-
+```
+**Remember that the prototype is like the "recipe" for creating an object**. In a way, the recipe for Bird now includes all the key "ingredients" from `Animal`.
+```js
 let duck = new Bird("Donald");
 duck.eat(); // prints "nom nom nom"
 duck inherits all of Animal's properties, including the eat method.
 
-
-Modify the code so that instances of Dog inherit from Animal.*/
-
+```
+Modify the code so that instances of `Dog` inherit from `Animal`.
+```js
 function Animal() { }
 
 Animal.prototype = {