{ "name": "Object Oriented Programming", "order": 7, "time": "5 hours", "helpRoom": "Help", "challenges": [ { "id": "587d7dac367417b2b2512b72", "title": "Introduction to the Object Oriented Programming Challenges", "description": [ [ "", "", "At its core, software development solves a problem or achieves a result with computation. The software development process first defines a problem, then presents a solution. Object oriented programming is one of several major approaches to the software development process.

As its name implies, object oriented programming organizes code into object definitions. These are sometimes called classes, and they group together data with related behavior. The data is an object's attributes, and the behavior (or functions) are methods.

The object structure makes it flexible within a program. Objects can transfer information by calling and passing data to another object's methods. Also, new classes can receive, or inherit, all the features from a base or parent class. This helps to reduce repeated code.

Your choice of programming approach depends on a few factors. These include the type of problem, as well as how you want to structure your data and algorithms. This section covers object oriented programming principles in JavaScript.", "" ] ], "releasedOn": "Feb 17, 2017", "challengeSeed": [], "tests": [], "type": "waypoint", "challengeType": 7, "isRequired": false, "translations": {} }, { "id": "587d7dac367417b2b2512b73", "title": "Create a Basic JavaScript Object", "description": [ "Think about things people see everyday, like cars, shops, and birds. These are all objects: tangible things people can observe and interact with.", "What are some qualities of these objects? A car has wheels. Shops sell items. Birds have wings.", "These qualities, or properties, define what makes up an object. Note that similar objects share the same properties, but may have different values for those properties. For example, all cars have wheels, but not all cars have the same number of wheels.", "Objects in JavaScript are used to model real-world objects, giving them properties and behavior just like their real-world counterparts. Here's an example using these concepts to create a duck object:", "
let duck = {
  name: \"Aflac\",
  numLegs: 2
};
", "This duck object has two property/value pairs: a name of \"Aflac\" and a numLegs of 2.", "
", "Create a dog object with name and numLegs properties, and set them to a string and a number, respectively." ], "challengeSeed": [ "let dog = {", " ", "};" ], "tests": [ "assert(typeof(dog) === 'object', 'message: dog should be an object.');", "assert(typeof(dog.name) === 'string', 'message: dog should have a name property set to a string.');", "assert(typeof(dog.numLegs) === 'number', 'message: dog should have a numLegs property set to a number.');" ], "solutions": [ "let dog = {\n name: '',\n numLegs: 4\n};" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7dac367417b2b2512b74", "title": "Use Dot Notation to Access the Properties of an Object", "description": [ "The last challenge created an object with various properties, now you'll see how to access the values of those properties. Here's an example:", "
let duck = {
  name: \"Aflac\",
  numLegs: 2
};
console.log(duck.name);
// This prints \"Aflac\" to the console
", "Dot notation is used on the object name, duck, followed by the name of the property, name, to access the value of \"Aflac\".", "
", "Print both properties of the dog object below to your console." ], "challengeSeed": [ "let dog = {", " name: \"Spot\",", " numLegs: 4", "};", "// Add your code below this line", "", "" ], "tests": [ "assert(/console.log\\(.*dog\\.name.*\\)/g.test(code), 'message: Your should use console.log to print the value for the name property of the dog object.');", "assert(/console.log\\(.*dog\\.numLegs.*\\)/g.test(code), 'message: Your should use console.log to print the value for the numLegs property of the dog object.');" ], "solutions": [ "let dog = {\n name: \"Spot\",\n numLegs: 4\n};\nconsole.log(dog.name);\nconsole.log(dog.numLegs);" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7dad367417b2b2512b75", "title": "Create a Method on an Object", "description": [ "Objects can have a special type of property, called a method.", "Methods are properties that are functions. This adds different behavior to an object. Here is the duck example with a method:", "
let duck = {
  name: \"Aflac\",
  numLegs: 2,
  sayName: function() {return \"The name of this duck is \" + duck.name + \".\";}
};
duck.sayName();
// Returns \"The name of this duck is Aflac.\"
", "The example adds the sayName method, which is a function that returns a sentence giving the name of the duck.", "Notice that the method accessed the name property in the return statement using duck.name. The next challenge will cover another way to do this.", "
", "Using the dog object, give it a method called sayLegs. The method should return the sentence \"This dog has 4 legs.\"" ], "challengeSeed": [ "let dog = {", " name: \"Spot\",", " numLegs: 4,", " ", "};", "", "dog.sayLegs();" ], "tests": [ "assert(typeof(dog.sayLegs) === 'function', 'message: dog.sayLegs() should be a function.');", "assert(dog.sayLegs() === 'This dog has 4 legs.', 'message: dog.sayLegs() should return the given string - note that punctuation and spacing matter.');" ], "solutions": [ "let dog = {\n name: \"Spot\",\n numLegs: 4,\n sayLegs () {\n return 'This dog has ' + this.numLegs + ' legs.';\n }\n};\n\ndog.sayLegs();" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7dad367417b2b2512b76", "title": "Make Code More Reusable with the this Keyword", "description": [ "The last challenge introduced a method to the duck object. It used duck.name dot notation to access the value for the name property within the return statement:", "sayName: function() {return \"The name of this duck is \" + duck.name + \".\";}", "While this is a valid way to access the object's property, there is a pitfall here. If the variable name changes, any code referencing the original name would need to be updated as well. In a short object definition, it isn't a problem, but if an object has many references to its properties there is a greater chance for error.", "A way to avoid these issues is with the this keyword:", "
let duck = {
  name: \"Aflac\",
  numLegs: 2,
  sayName: function() {return \"The name of this duck is \" + this.name + \".\";}
};
", "this is a deep topic, and the above example is only one way to use it. In the current context, this refers to the object that the method is associated with: duck.", "If the object's name is changed to mallard, it is not necessary to find all the references to duck in the code. It makes the code reusable and easier to read.", "
", "Modify the dog.sayLegs method to remove any references to dog. Use the duck example for guidance." ], "challengeSeed": [ "let dog = {", " name: \"Spot\",", " numLegs: 4,", " sayLegs: function() {return \"This dog has \" + dog.numLegs + \" legs.\";}", "};", "", "dog.sayLegs();" ], "tests": [ "assert(dog.sayLegs() === 'This dog has 4 legs.', 'message: dog.sayLegs() should return the given string.');", "assert(code.match(/this\\.numLegs/g), 'message: Your code should use the this keyword to access the numLegs property of dog.');" ], "solutions": [ "let dog = {\n name: \"Spot\",\n numLegs: 4,\n sayLegs () {\n return 'This dog has ' + this.numLegs + ' legs.';\n }\n};\n\ndog.sayLegs();" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7dad367417b2b2512b77", "title": "Define a Constructor Function", "description": [ "Constructors are functions that create new objects. They define properties and behaviors that will belong to the new object. Think of them as a blueprint for the creation of new objects.", "Here is an example of a constructor:", "
function Bird() {
  this.name = \"Albert\";
  this.color = \"blue\";
  this.numLegs = 2;
}
", "This constructor defines a Bird object with properties name, color, and numLegs set to Albert, blue, and 2, respectively.", "Constructors follow a few conventions:", "", "
", "Create a constructor, Dog, with properties name, color, and numLegs that are set to a string, a string, and a number, respectively." ], "challengeSeed": [], "tests": [ "assert(typeof (new Dog()).name === 'string', 'message: Dog should have a name property set to a string.');", "assert(typeof (new Dog()).color === 'string', 'message: Dog should have a color property set to a string.');", "assert(typeof (new Dog()).numLegs === 'number', 'message: Dog should have a numLegs property set to a number.');" ], "solutions": [ "function Dog (name, color, numLegs) {\n this.name = 'name';\n this.color = 'color';\n this.numLegs = 4;\n}" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7dad367417b2b2512b78", "title": "Use a Constructor to Create Objects", "description": [ "Here's the Bird constructor from the previous challenge:", "
function Bird() {
  this.name = \"Albert\";
  this.color = \"blue\";
  this.numLegs = 2;
  // \"this\" inside the constructor always refers to the object being created
}

let blueBird = new Bird();
", "Notice that the new operator is used when calling a constructor. This tells JavaScript to create a new instance of Bird called blueBird. Without the new operator, this inside the constructor would not point to the newly created object, giving unexpected results.", "Now blueBird has all the properties defined inside the Bird constructor:", "
blueBird.name; // => Albert
blueBird.color; // => blue
blueBird.numLegs; // => 2
", "Just like any other object, its properties can be accessed and modified:", "
blueBird.name = 'Elvira';
blueBird.name; // => Elvira
", "
", "Use the Dog constructor from the last lesson to create a new instance of Dog, assigning it to a variable hound." ], "challengeSeed": [ "function Dog() {", " this.name = \"Rupert\";", " this.color = \"brown\";", " this.numLegs = 4;", "}", "// Add your code below this line", "", "" ], "tests": [ "assert(hound instanceof Dog, 'message: hound should be created using the Dog constructor.');", "assert(code.match(/new/g), 'message: Your code should use the new operator to create an instance of Dog.');" ], "solutions": [ "function Dog() {\n this.name = \"Rupert\";\n this.color = \"brown\";\n this.numLegs = 4;\n}\nconst hound = new Dog();" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7dae367417b2b2512b79", "title": "Extend Constructors to Receive Arguments", "description": [ "The Bird and Dog constructors from last challenge worked well. However, notice that all Birds that are created with the Bird constructor are automatically named Albert, are blue in color, and have two legs. What if you want birds with different values for name and color? It's possible to change the properties of each bird manually but that would be a lot of work:", "
let swan = new Bird();
swan.name = \"Carlos\";
swan.color = \"white\";
", "Suppose you were writing a program to keep track of hundreds or even thousands of different birds in an aviary. It would take a lot of time to create all the birds, then change the properties to different values for every one.", "To more easily create different Bird objects, you can design your Bird constructor to accept parameters:", "
function Bird(name, color) {
  this.name = name;
  this.color = color;
  this.numLegs = 2;
}
", "Then pass in the values as arguments to define each unique bird into the Bird constructor:", "let cardinal = new Bird(\"Bruce\", \"red\");", "This gives a new instance of Bird with name and color properties set to Bruce and red, respectively. The numLegs property is still set to 2.", "The cardinal has these properties:", "
cardinal.name // => Bruce
cardinal.color // => red
cardinal.numLegs // => 2
", "The constructor is more flexible. It's now possible to define the properties for each Bird at the time it is created, which is one way that JavaScript constructors are so useful. They group objects together based on shared characteristics and behavior and define a blueprint that automates their creation.", "
", "Create another Dog constructor. This time, set it up to take the parameters name and color, and have the property numLegs fixed at 4. Then create a new Dog saved in a variable terrier. Pass it two strings as arguments for the name and color properties." ], "challengeSeed": [ "function Dog() {", " ", "}", "", "" ], "tests": [ "assert((new Dog('Clifford')).name === 'Clifford', 'message: Dog should receive an argument for name.');", "assert((new Dog('Clifford', 'yellow')).color === 'yellow', 'message: Dog should receive an argument for color.');", "assert((new Dog('Clifford')).numLegs === 4, 'message: Dog should have property numLegs set to 4.');", "assert(terrier instanceof Dog, 'message: terrier should be created using the Dog constructor.');" ], "solutions": [ "function Dog (name, color) {\n this.numLegs = 4;\n this.name = name;\n this.color = color;\n}\n\nconst terrier = new Dog();" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7dae367417b2b2512b7a", "title": "Verify an Object's Constructor with instanceof", "description": [ "Anytime a constructor function creates a new object, that object is said to be an instance of its constructor. JavaScript gives a convenient way to verify this with the instanceof operator. instanceof allows you to compare an object to a constructor, returning true or false based on whether or not that object was created with the constructor. Here's an example:", "
let Bird = function(name, color) {
  this.name = name;
  this.color = color;
  this.numLegs = 2;
}

let crow = new Bird(\"Alexis\", \"black\");

crow instanceof Bird; // => true
", "If an object is created without using a constructor, instanceof will verify that it is not an instance of that constructor:", "
let canary = {
  name: \"Mildred\",
  color: \"Yellow\",
  numLegs: 2
};

canary instanceof Bird; // => false
", "
", "Create a new instance of the House constructor, calling it myHouse and passing a number of bedrooms. Then, use instanceof to verify that it is an instance of House." ], "challengeSeed": [ "/* jshint expr: true */", "", "function House(numBedrooms) {", " this.numBedrooms = numBedrooms;", "}", "", "// Add your code below this line", "", "", "" ], "tests": [ "assert(typeof myHouse.numBedrooms === 'number', 'message: myHouse should have a numBedrooms attribute set to a number.');", "assert(/myHouse\\s*instanceof\\s*House/.test(code), 'message: Be sure to verify that myHouse is an instance of House using the instanceof operator.');" ], "solutions": [ "function House(numBedrooms) {\n this.numBedrooms = numBedrooms;\n}\nconst myHouse = new House(4);\nconsole.log(myHouse instanceof House);" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7dae367417b2b2512b7b", "title": "Understand Own Properties", "description": [ "In the following example, the Bird constructor defines two properties: name and numLegs:", "
function Bird(name) {
  this.name = name;
  this.numLegs = 2;
}

let duck = new Bird(\"Donald\");
let canary = new Bird(\"Tweety\");
", "name and numLegs are called own properties, because they are defined directly on the instance object. That means that duck and canary each has its own separate copy of these properties.", "In fact every instance of Bird will have its own copy of these properties.", "The following code adds all of the own properties of duck to the array ownProps:", "
let ownProps = [];

for (let property in duck) {
  if(duck.hasOwnProperty(property)) {
    ownProps.push(property);
  }
}

console.log(ownProps); // prints [ \"name\", \"numLegs\" ]
", "
", "Add the own properties of canary to the array ownProps." ], "challengeSeed": [ "function Bird(name) {", " this.name = name;", " this.numLegs = 2;", "}", "", "let canary = new Bird(\"Tweety\");", "let ownProps = [];", "// Add your code below this line", "", "", "" ], "tests": [ "assert(ownProps.indexOf('name') !== -1 && ownProps.indexOf('numLegs') !== -1, 'message: ownProps should include the values \"numLegs\" and \"name\".');", "assert(!/\\Object.keys/.test(code), 'message: Solve this challenge without using the built in method Object.keys().');" ], "solutions": [ "function Bird(name) {\n this.name = name;\n this.numLegs = 2;\n}\n\nlet canary = new Bird(\"Tweety\");\nfunction getOwnProps (obj) {\n const props = [];\n \n for (let prop in obj) {\n if (obj.hasOwnProperty(prop)) {\n props.push(prop);\n }\n }\n \n return props;\n}\n\nconst ownProps = getOwnProps(canary);" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7dae367417b2b2512b7c", "title": "Use Prototype Properties to Reduce Duplicate Code", "description": [ "Since numLegs will probably have the same value for all instances of Bird, you essentially have a duplicated variable numLegs inside each Bird instance.", "This may not be an issue when there are only two instances, but imagine if there are millions of instances. That would be a lot of duplicated variables.", "A better way is to use Bird’s prototype. The prototype is an object that is shared among ALL instances of Bird. Here's how to add numLegs to the Bird prototype:", "
Bird.prototype.numLegs = 2;
", "Now all instances of Bird have the numLegs property.", "
console.log(duck.numLegs); // prints 2
console.log(canary.numLegs); // prints 2
", "Since all instances automatically have the properties on the prototype, think of a prototype as a \"recipe\" for creating objects.", "Note that the prototype for duck and canary is part of the Bird constructor as Bird.prototype. Nearly every object in JavaScript has a prototype property which is part of the constructor function that created it.", "
", "Add a numLegs property to the prototype of Dog" ], "challengeSeed": [ "function Dog(name) {", " this.name = name;", "}", "", "", "", "// Add your code above this line", "let beagle = new Dog(\"Snoopy\");" ], "tests": [ "assert(beagle.numLegs !== undefined, 'message: beagle should have a numLegs property.');", "assert(typeof(beagle.numLegs) === 'number' , 'message: beagle.numLegs should be a number.');", "assert(beagle.hasOwnProperty('numLegs') === false, 'message: numLegs should be a prototype property not an own property.');" ], "solutions": [ "function Dog (name) {\n this.name = name;\n}\nDog.prototype.numLegs = 4;\nlet beagle = new Dog(\"Snoopy\");" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7daf367417b2b2512b7d", "title": "Iterate Over All Properties", "description": [ "You have now seen two kinds of properties: own properties and prototype properties. Own properties are defined directly on the object instance itself. And prototype properties are defined on the prototype.", "
function Bird(name) {
  this.name = name; //own property
}

Bird.prototype.numLegs = 2; // prototype property

let duck = new Bird(\"Donald\");
", "Here is how you add duck’s own properties to the array ownProps and prototype properties to the array prototypeProps:", "
let ownProps = [];
let prototypeProps = [];

for (let property in duck) {
  if(duck.hasOwnProperty(property)) {
    ownProps.push(property);
  } else {
    prototypeProps.push(property);
  }
}

console.log(ownProps); // prints [\"name\"]
console.log(prototypeProps); // prints [\"numLegs\"]
", "
", "Add all of the own properties of beagle to the array ownProps. Add all of the prototype properties of Dog to the array prototypeProps." ], "challengeSeed": [ "function Dog(name) {", " this.name = name;", "}", "", "Dog.prototype.numLegs = 4;", "", "let beagle = new Dog(\"Snoopy\");", "", "let ownProps = [];", "let prototypeProps = [];", "", "// Add your code below this line ", "", "", "" ], "tests": [ "assert(ownProps.indexOf('name') !== -1, 'message: The ownProps array should include \"name\".');", "assert(prototypeProps.indexOf('numLegs') !== -1, 'message: The prototypeProps array should include \"numLegs\".');", "assert(!/\\Object.keys/.test(code), 'message: Solve this challenge without using the built in method Object.keys().');" ], "solutions": [ "function Dog(name) {\n this.name = name;\n}\n\nDog.prototype.numLegs = 4;\n\nlet beagle = new Dog(\"Snoopy\");\n\nlet ownProps = [];\nlet prototypeProps = [];\nfor (let prop in beagle) {\n if (beagle.hasOwnProperty(prop)) {\n ownProps.push(prop);\n } else {\n prototypeProps.push(prop);\n }\n}" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7daf367417b2b2512b7e", "title": "Understand the Constructor Property", "description": [ "There is a special constructor property located on the object instances duck and beagle that were created in the previous challenges:", "
let duck = new Bird();
let beagle = new Dog();

console.log(duck.constructor === Bird); //prints true
console.log(beagle.constructor === Dog); //prints true
", "Note that the constructor property is a reference to the constructor function that created the instance.", "The advantage of the constructor property is that it's possible to check for this property to find out what kind of object it is. Here's an example of how this could be used:", "
function joinBirdFraternity(candidate) {
  if (candidate.constructor === Bird) {
    return true;
  } else {
    return false;
  }
}
", "Note
Since the constructor property can be overwritten (which will be covered in the next two challenges) it’s generally better to use the instanceof method to check the type of an object.", "
", "Write a joinDogFraternity function that takes a candidate parameter and, using the constructor property, return true if the candidate is a Dog, otherwise return false." ], "challengeSeed": [ "function Dog(name) {", " this.name = name;", "}", "", "// Add your code below this line", "function joinDogFraternity(candidate) {", " ", "}", "" ], "tests": [ "assert(typeof(joinDogFraternity) === 'function', 'message: joinDogFraternity should be defined as a function.');", "assert(joinDogFraternity(new Dog(\"\")) === true, 'message: joinDogFraternity should return true ifcandidate is an instance of Dog.');", "assert(/\\.constructor/.test(code) && !/instanceof/.test(code), 'message: joinDogFraternity should use the constructor property.');" ], "solutions": [ "function Dog(name) {\n this.name = name;\n}\nfunction joinDogFraternity(candidate) {\n return candidate.constructor === Dog;\n}" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7daf367417b2b2512b7f", "title": "Change the Prototype to a New Object", "description": [ "Up until now you have been adding properties to the prototype individually:", "
Bird.prototype.numLegs = 2;
", "This becomes tedious after more than a few properties.", "
Bird.prototype.eat = function() {
  console.log(\"nom nom nom\");
}

Bird.prototype.describe = function() {
  console.log(\"My name is \" + this.name);
}
", "A more efficient way is to set the prototype to a new object that already contains the properties. This way, the properties are added all at once:", "
Bird.prototype = {
  numLegs: 2,
  eat: function() {
    console.log(\"nom nom nom\");
  },
  describe: function() {
    console.log(\"My name is \" + this.name);
  }
};
", "
", "Add the property numLegs and the two methods eat() and describe() to the prototype of Dog by setting the prototype to a new object." ], "challengeSeed": [ "function Dog(name) {", " this.name = name; ", "}", "", "Dog.prototype = {", " // Add your code below this line", " ", "};" ], "tests": [ "assert((/Dog\\.prototype\\s*?=\\s*?{/).test(code), 'message: Dog.prototype should be set to a new object.');", "assert(Dog.prototype.numLegs !== undefined, 'message: Dog.prototype should have the property numLegs.');", "assert(typeof Dog.prototype.eat === 'function', 'message: Dog.prototype should have the method eat().'); ", "assert(typeof Dog.prototype.describe === 'function', 'message: Dog.prototype should have the method describe().'); " ], "solutions": [ "function Dog(name) {\n this.name = name; \n}\nDog.prototype = {\nnumLegs: 4,\n eat () {\n console.log('nom nom nom');\n },\n describe () {\n console.log('My name is ' + this.name);\n }\n};" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7daf367417b2b2512b80", "title": "Remember to Set the Constructor Property when Changing the Prototype", "description": [ "There is one crucial side effect of manually setting the prototype to a new object. It erased the constructor property! The code in the previous challenge would print the following for duck:", "
console.log(duck.constructor)
// prints ‘undefined’ - Oops!
", "To fix this, whenever a prototype is manually set to a new object, remember to define the constructor property:", "
Bird.prototype = {
  constructor: Bird, // define the constructor property
  numLegs: 2,
  eat: function() {
    console.log(\"nom nom nom\");
  },
  describe: function() {
    console.log(\"My name is \" + this.name);
  }
};
", "
", "Define the constructor property on the Dog prototype." ], "challengeSeed": [ "function Dog(name) {", " this.name = name; ", "}", "", "// Modify the code below this line", "Dog.prototype = {", " ", " numLegs: 2, ", " eat: function() {", " console.log(\"nom nom nom\"); ", " }, ", " describe: function() {", " console.log(\"My name is \" + this.name); ", " }", "};" ], "tests": [ "assert(Dog.prototype.constructor === Dog, 'message: Dog.prototype should set the constructor property.');" ], "solutions": [ "function Dog(name) {\n this.name = name; \n}\nDog.prototype = {\n constructor: Dog,\n numLegs: 2, \n eat: function() {\n console.log(\"nom nom nom\"); \n }, \n describe: function() {\n console.log(\"My name is \" + this.name); \n }\n};" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7db0367417b2b2512b81", "title": "Understand Where an Object’s Prototype Comes From", "description": [ "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:", "
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:", "
Bird.prototype.isPrototypeOf(duck);
// returns true
", "
", "Use isPrototypeOf to check the prototype of beagle." ], "challengeSeed": [ "function Dog(name) {", " this.name = name;", "}", "", "let beagle = new Dog(\"Snoopy\");", "", "// Add your code below this line", "", "" ], "tests": [ "assert(/Dog\\.prototype\\.isPrototypeOf\\(beagle\\)/.test(code), 'message: Show that Dog.prototype is the prototype of beagle');" ], "solutions": [ "function Dog(name) {\n this.name = name;\n}\nlet beagle = new Dog(\"Snoopy\");\nDog.prototype.isPrototypeOf(beagle);" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7db0367417b2b2512b82", "title": "Understand the Prototype Chain", "description": [ "All objects in JavaScript (with a few exceptions) have a prototype. Also, an object’s prototype itself is an object.", "
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:", "
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.", "
", "Modify the code to show the correct prototype chain." ], "challengeSeed": [ "function Dog(name) {", " this.name = name;", "}", "", "let beagle = new Dog(\"Snoopy\");", "", "Dog.prototype.isPrototypeOf(beagle); // => true", "", "// Fix the code below so that it evaluates to true", "???.isPrototypeOf(Dog.prototype);", "" ], "tests": [ "assert(/Object\\.prototype\\.isPrototypeOf/.test(code), \"message: Your code should show that Object.prototype is the prototype of Dog.prototype\");" ], "solutions": [ "function Dog(name) {\n this.name = name;\n}\nlet beagle = new Dog(\"Snoopy\");\nDog.prototype.isPrototypeOf(beagle);\nObject.prototype.isPrototypeOf(Dog.prototype);" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7db0367417b2b2512b83", "title": "Use Inheritance So You Don't Repeat Yourself", "description": [ "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:", "
Bird.prototype = {
  constructor: Bird,
  describe: function() {
    console.log(\"My name is \" + this.name);
  }
};

Dog.prototype = {
  constructor: Dog,
  describe: function() {
    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:", "
function Animal() { };

Animal.prototype = {
  constructor: Animal,
  describe: function() {
    console.log(\"My name is \" + this.name);
  }
};
", "Since Animal includes the describe method, you can remove it from Bird and Dog:", "
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." ], "challengeSeed": [ "function Cat(name) {", " this.name = name; ", "}", "", "Cat.prototype = {", " constructor: Cat, ", " eat: function() {", " console.log(\"nom nom nom\");", " }", "};", "", "function Bear(name) {", " this.name = name; ", "}", "", "Bear.prototype = {", " constructor: Bear, ", " eat: function() {", " console.log(\"nom nom nom\");", " }", "};", "", "function Animal() { }", "", "Animal.prototype = {", " constructor: Animal,", " ", "};" ], "tests": [ "assert(Animal.prototype.hasOwnProperty('eat'), 'message: Animal.prototype should have the eat property.');", "assert(!(Bear.prototype.hasOwnProperty('eat')), 'message: Bear.prototype should not have the eat property.');", "assert(!(Cat.prototype.hasOwnProperty('eat')), 'message: Cat.prototype should not have the eat property.');" ], "solutions": [ "function Cat(name) {\n this.name = name; \n}\n\nCat.prototype = {\n constructor: Cat\n};\n\nfunction Bear(name) {\n this.name = name; \n}\n\nBear.prototype = {\n constructor: Bear\n};\n\nfunction Animal() { }\n\nAnimal.prototype = {\n constructor: Animal,\n eat: function() {\n console.log(\"nom nom nom\");\n }\n};" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7db0367417b2b2512b84", "title": "Inherit Behaviors from a Supertype", "description": [ "In the previous challenge, you created a supertype called Animal that defined behaviors shared by all animals:", "
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:", "
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:", "
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.", "
animal.eat(); // prints \"nom nom nom\"
animal instanceof Animal; // => true
", "
", "Use Object.create to make two instances of Animal named duck and beagle." ], "challengeSeed": [ "function Animal() { }", "", "Animal.prototype = {", " constructor: Animal, ", " eat: function() {", " console.log(\"nom nom nom\");", " }", "};", "", "// Add your code below this line", "", "let duck; // Change this line", "let beagle; // Change this line", "", "duck.eat(); // Should print \"nom nom nom\"", "beagle.eat(); // Should print \"nom nom nom\" " ], "tests": [ "assert(typeof duck !== \"undefined\", 'message: The duck variable should be defined.');", "assert(typeof beagle !== \"undefined\", 'message: The beagle variable should be defined.');", "assert(duck instanceof Animal, 'message: duck should have a prototype of Animal.');", "assert(beagle instanceof Animal, 'message: beagle should have a prototype of Animal.');" ], "solutions": [ "function Animal() { }\n\nAnimal.prototype = {\n constructor: Animal, \n eat: function() {\n console.log(\"nom nom nom\");\n }\n};\nlet duck = Object.create(Animal.prototype);\nlet beagle = Object.create(Animal.prototype);\n\nduck.eat();\nbeagle.eat();" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7db1367417b2b2512b85", "title": "Set the Child's Prototype to an Instance of the Parent", "description": [ "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.", "
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.", "
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." ], "challengeSeed": [ "function Animal() { }", "", "Animal.prototype = {", " constructor: Animal,", " eat: function() {", " console.log(\"nom nom nom\");", " }", "};", "", "function Dog() { }", "", "// Add your code below this line", "", "", "let beagle = new Dog();", "beagle.eat(); // Should print \"nom nom nom\"" ], "tests": [ "assert(Animal.prototype.isPrototypeOf(Dog.prototype), 'message: Dog.prototype should be an instance of Animal.');" ], "solutions": [ "function Animal() { }\n\nAnimal.prototype = {\n constructor: Animal,\n eat: function() {\n console.log(\"nom nom nom\");\n }\n};\n\nfunction Dog() { }\nDog.prototype = Object.create(Animal.prototype);\n\nlet beagle = new Dog();\nbeagle.eat();" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7db1367417b2b2512b86", "title": "Reset an Inherited Constructor Property", "description": [ "When an object inherits its prototype from another object, it also inherits the supertype's constructor property.", "Here's an example:", "
function Bird() { }
Bird.prototype = Object.create(Animal.prototype);
let duck = new Bird();
duck.constructor // function Animal(){...}
", "But duck and all instances of Bird should show that they were constructed by Bird and not Animal. To do so, you can manually set Bird's constructor property to the Bird object:", "
Bird.prototype.constructor = Bird;
duck.constructor // function Bird(){...}
", "
", "Fix the code so duck.constructor and beagle.constructor return their respective constructors." ], "challengeSeed": [ "function Animal() { }", "function Bird() { }", "function Dog() { }", "", "Bird.prototype = Object.create(Animal.prototype);", "Dog.prototype = Object.create(Animal.prototype);", "", "// Add your code below this line", "", "", "", "let duck = new Bird();", "let beagle = new Dog();" ], "tests": [ "assert(Animal.prototype.isPrototypeOf(Bird.prototype), 'message: Bird.prototype should be an instance of Animal.');", "assert(duck.constructor === Bird, 'message: duck.constructor should return Bird.');", "assert(Animal.prototype.isPrototypeOf(Dog.prototype), 'message: Dog.prototype should be an instance of Animal.');", "assert(beagle.constructor === Dog, 'message: beagle.constructor should return Dog.');" ], "solutions": [ "function Animal() { }\nfunction Bird() { }\nfunction Dog() { }\nBird.prototype = Object.create(Animal.prototype);\nDog.prototype = Object.create(Animal.prototype);\nDog.prototype.constructor = Dog;\nBird.prototype.constructor = Bird;\nlet duck = new Bird();\nlet beagle = new Dog();" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7db1367417b2b2512b87", "title": "Add Methods After Inheritance", "description": [ "A constructor function that inherits its prototype object from a supertype constructor function can still have its own methods in addition to inherited methods.", "For example, Bird is a constructor that inherits its prototype from Animal:", "
function Animal() { }
Animal.prototype.eat = function() {
  console.log(\"nom nom nom\");
};
function Bird() { }
Bird.prototype = Object.create(Animal.prototype);
Bird.prototype.constructor = Bird;
", "In addition to what is inherited from Animal, you want to add behavior that is unique to Bird objects. Here, Bird will get a fly() function. Functions are added to Bird's prototype the same way as any constructor function:", "
Bird.prototype.fly = function() {
  console.log(\"I'm flying!\");
};
", "Now instances of Bird will have both eat() and fly() methods:", "
let duck = new Bird();
duck.eat(); // prints \"nom nom nom\"
duck.fly(); // prints \"I'm flying!\"
", "
", "Add all necessary code so the Dog object inherits from Animal and the Dog's prototype constructor is set to Dog. Then add a bark() method to the Dog object so that beagle can both eat() and bark(). The bark() method should print \"Woof!\" to the console." ], "challengeSeed": [ "function Animal() { }", "Animal.prototype.eat = function() { console.log(\"nom nom nom\"); };", "", "function Dog() { }", "", "// Add your code below this line", "", "", "", "", "// Add your code above this line", "", "let beagle = new Dog();", "", "beagle.eat(); // Should print \"nom nom nom\"", "beagle.bark(); // Should print \"Woof!\"" ], "tests": [ "assert(typeof Animal.prototype.bark == \"undefined\", 'message: Animal should not respond to the bark() method.');", "assert(typeof Dog.prototype.eat == \"function\", 'message: Dog should inherit the eat() method from Animal.');", "assert(Dog.prototype.hasOwnProperty('bark'), 'message: Dog should have the bark() method as an own property.');", "assert(beagle instanceof Animal, 'message: beagle should be an instanceof Animal.');", "assert(beagle.constructor === Dog, 'message: The constructor for beagle should be set to Dog.');" ], "solutions": [ "function Animal() { }\nAnimal.prototype.eat = function() { console.log(\"nom nom nom\"); };\n\nfunction Dog() { }\nDog.prototype = Object.create(Animal.prototype);\nDog.prototype.constructor = Dog;\nDog.prototype.bark = function () {\n console.log('Woof!');\n};\nlet beagle = new Dog();\n\nbeagle.eat();\nbeagle.bark();" ], "hints": [ "Objects inherit methods from other objects by cloning their prototype. The Object.create method will come in handy, and don't forget to reset the constructor property afterward!" ], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7db1367417b2b2512b88", "title": "Override Inherited Methods", "description": [ "In previous lessons, you learned that an object can inherit its behavior (methods) from another object by cloning its prototype object:", "
ChildObject.prototype = Object.create(ParentObject.prototype);
", "Then the ChildObject received its own methods by chaining them onto its prototype:", "
ChildObject.prototype.methodName = function() {...};
", "It's possible to override an inherited method. It's done the same way - by adding a method to ChildObject.prototype using the same method name as the one to override.", "Here's an example of Bird overriding the eat() method inherited from Animal:", "
function Animal() { }
Animal.prototype.eat = function() {
  return \"nom nom nom\";
};
function Bird() { }

// Inherit all methods from Animal
Bird.prototype = Object.create(Animal.prototype);

// Bird.eat() overrides Animal.eat()
Bird.prototype.eat = function() {
  return \"peck peck peck\";
};
", "If you have an instance let duck = new Bird(); and you call duck.eat(), this is how JavaScript looks for the method on duck’s prototype chain:", "1. duck => Is eat() defined here? No.", "2. Bird => Is eat() defined here? => Yes. Execute it and stop searching.", "3. Animal => eat() is also defined, but JavaScript stopped searching before reaching this level.", "4. Object => JavaScript stopped searching before reaching this level.", "
", "Override the fly() method for Penguin so that it returns \"Alas, this is a flightless bird.\"" ], "challengeSeed": [ "function Bird() { }", "", "Bird.prototype.fly = function() { return \"I am flying!\"; };", "", "function Penguin() { }", "Penguin.prototype = Object.create(Bird.prototype);", "Penguin.prototype.constructor = Penguin;", "", "// Add your code below this line", "", "", "", "// Add your code above this line", "", "let penguin = new Penguin();", "console.log(penguin.fly());" ], "tests": [ "assert(penguin.fly() === \"Alas, this is a flightless bird.\", 'message: penguin.fly() should return the string \"Alas, this is a flightless bird.\"');", "assert((new Bird()).fly() === \"I am flying!\", 'message: The bird.fly() method should return \"I am flying!\"');" ], "solutions": [ "function Bird() { }\n\nBird.prototype.fly = function() { return \"I am flying!\"; };\n\nfunction Penguin() { }\nPenguin.prototype = Object.create(Bird.prototype);\nPenguin.prototype.constructor = Penguin;\nPenguin.prototype.fly = () => 'Alas, this is a flightless bird.';\nlet penguin = new Penguin();\nconsole.log(penguin.fly());" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7db2367417b2b2512b89", "title": "Use a Mixin to Add Common Behavior Between Unrelated Objects", "description": [ "As you have seen, behavior is shared through inheritance. However, there are cases when inheritance is not the best solution. Inheritance does not work well for unrelated objects like Bird and Airplane. They can both fly, but a Bird is not a type of Airplane and vice versa.", "For unrelated objects, it's better to use mixins. A mixin allows other objects to use a collection of functions.", "
let flyMixin = function(obj) {
  obj.fly = function() {
    console.log(\"Flying, wooosh!\");
  }
};
", "The flyMixin takes any object and gives it the fly method.", "
let bird = {
  name: \"Donald\",
  numLegs: 2
};

let plane = {
  model: \"777\",
  numPassengers: 524
};

flyMixin(bird);
flyMixin(plane);
", "Here bird and plane are passed into flyMixin, which then assigns the fly function to each object. Now bird and plane can both fly:", "
bird.fly(); // prints \"Flying, wooosh!\"
plane.fly(); // prints \"Flying, wooosh!\"
", "Note how the mixin allows for the same fly method to be reused by unrelated objects bird and plane.", "
", "Create a mixin named glideMixin that defines a method named glide. Then use the glideMixin to give both bird and boat the ability to glide." ], "challengeSeed": [ "let bird = {", " name: \"Donald\",", " numLegs: 2", "};", "", "let boat = {", " name: \"Warrior\",", " type: \"race-boat\"", "};", "", "// Add your code below this line", "", "", "", "", "", "" ], "tests": [ "assert(typeof glideMixin === \"function\", 'message: Your code should declare a glideMixin variable that is a function.');", "assert(typeof bird.glide === \"function\", 'message: Your code should use the glideMixin on the bird object to give it the glide method.');", "assert(typeof boat.glide === \"function\", 'message: Your code should use the glideMixin on the boat object to give it the glide method.');" ], "solutions": [ "let bird = {\n name: \"Donald\",\n numLegs: 2\n};\n\nlet boat = {\n name: \"Warrior\",\n type: \"race-boat\"\n};\nfunction glideMixin (obj) {\n obj.glide = () => 'Gliding!';\n}\n\nglideMixin(bird);\nglideMixin(boat);" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7db2367417b2b2512b8a", "title": "Use Closure to Protect Properties Within an Object from Being Modified Externally", "description": [ "In the previous challenge, bird had a public property name. It is considered public because it can be accessed and changed outside of bird's definition.", "
bird.name = \"Duffy\";
", "Therefore, any part of your code can easily change the name of bird to any value. Think about things like passwords and bank accounts being easily changeable by any part of your codebase. That could cause a lot of issues.", "The simplest way to make properties private is by creating a variable within the constructor function. This changes the scope of that variable to be within the constructor function versus available globally. This way, the property can only be accessed and changed by methods also within the constructor function.", "
function Bird() {
  let hatchedEgg = 10; // private property

  this.getHatchedEggCount = function() { // publicly available method that a bird object can use
    return hatchedEgg;
  };
}
let ducky = new Bird();
ducky.getHatchedEggCount(); // returns 10
", "Here getHachedEggCount is a privileged method, because it has access to the private variable hatchedEgg. This is possible because hatchedEgg is declared in the same context as getHachedEggCount. In JavaScript, a function always has access to the context in which it was created. This is called closure.", "
", "Change how weight is declared in the Bird function so it is a private variable. Then, create a method getWeight that returns the value of weight." ], "challengeSeed": [ "function Bird() {", " this.weight = 15;", " ", " ", "}", "" ], "tests": [ "assert(!code.match(/this\\.weight/g), 'message: The weight property should be a private variable.');", "assert((new Bird()).getWeight() === 15, 'message: Your code should create a method in Bird called getWeight that returns the weight.');" ], "solutions": [ "function Bird() {\n let weight = 15;\n \n this.getWeight = () => weight;\n}" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7db2367417b2b2512b8b", "title": "Understand the Immediately Invoked Function Expression (IIFE)", "description": [ "A common pattern in JavaScript is to execute a function as soon as it is declared:", "
(function () {
  console.log(\"Chirp, chirp!\");
})(); // this is an anonymous function expression that executes right away
// Outputs \"Chirp, chirp!\" immediately
", "Note that the function has no name and is not stored in a variable. The two parentheses () at the end of the function expression cause it to be immediately executed or invoked. This pattern is known as an immediately invoked function expression or IIFE.", "
", "Rewrite the function makeNest and remove its call so instead it's an anonymous immediately invoked function expression (IIFE)." ], "challengeSeed": [ "function makeNest() {", " console.log(\"A cozy nest is ready\");", "}", "", "makeNest(); " ], "tests": [ "assert(/\\(\\s*?function\\s*?\\(\\s*?\\)\\s*?{/.test(code), 'message: The function should be anonymous.');", "assert(/}\\s*?\\)\\s*?\\(\\s*?\\)/.test(code), 'message: Your function should have parentheses at the end of the expression to call it immediately.');" ], "solutions": [ "(function () {\n console.log(\"A cozy nest is ready\");\n})();" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} }, { "id": "587d7db2367417b2b2512b8c", "title": "Use an IIFE to Create a Module", "description": [ "An immediately invoked function expression (IIFE) is often used to group related functionality into a single object or module. For example, an earlier challenge defined two mixins:", "
function glideMixin(obj) {
  obj.glide = function() {
    console.log(\"Gliding on the water\");
  };
}
function flyMixin(obj) {
  obj.fly = function() {
    console.log(\"Flying, wooosh!\");
  };
}
", "We can group these mixins into a module as follows:", "
let motionModule = (function () {
  return {
    glideMixin: function (obj) {
      obj.glide = function() {
        console.log(\"Gliding on the water\");
      };
    },
    flyMixin: function(obj) {
      obj.fly = function() {
        console.log(\"Flying, wooosh!\");
      };
    }
  }
}) (); // The two parentheses cause the function to be immediately invoked
", "Note that you have an immediately invoked function expression (IIFE) that returns an object motionModule. This returned object contains all of the mixin behaviors as properties of the object.", "The advantage of the module pattern is that all of the motion behaviors can be packaged into a single object that can then be used by other parts of your code. Here is an example using it:", "
motionModule.glideMixin(duck);
duck.glide();
", "
", "Create a module named funModule to wrap the two mixins isCuteMixin and singMixin. funModule should return an object." ], "challengeSeed": [ "let isCuteMixin = function(obj) {", " obj.isCute = function() {", " return true;", " };", "};", "let singMixin = function(obj) {", " obj.sing = function() {", " console.log(\"Singing to an awesome tune\");", " };", "};" ], "tests": [ "assert(typeof funModule === \"object\", 'message: funModule should be defined and return an object.');", "assert(typeof funModule.isCuteMixin === \"function\", 'message: funModule.isCuteMixin should access a function.');", "assert(typeof funModule.singMixin === \"function\", 'message: funModule.singMixin should access a function.');" ], "solutions": [ "const funModule = (function () {\n return {\n isCuteMixin: obj => {\n obj.isCute = () => true;\n },\n singMixin: obj => {\n obj.sing = () => console.log(\"Singing to an awesome tune\");\n }\n };\n})();" ], "hints": [], "type": "waypoint", "releasedOn": "Feb 17, 2017", "challengeType": 1, "translations": {} } ] }