Object Oriented Programming

Question 1

create a basic object

Answer 1

var dog = {
name: "Fido",
numLegs: 4
}

Question 2

call object’s properties

Answer 2

object.property

Question 3

Methods are properties that are

Answer 3

functions

Question 4

Constructors are defined with _____ to distinguish them from other functions that are not constructors.

Answer 4

a capitalized name

Question 5

Verify an Object’s Constructor with

Answer 5

instanceof

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.

let crow = new Bird(“Alexis”, “black”);

crow instanceof Bird; // => true

Question 6

every instance of Object will have its own copy of these properties T/F?

Answer 6

true

collect own properties from each instance in an array like so

let canary = new Bird("Tweety");
let ownProps = [];
// Only change code below this line
for(let property in canary){
  if(canary.hasOwnProperty(property)){
    ownProps.push(property);
  }
}

Question 7

Properties in the prototype are shared…

Answer 7

shared among ALL instances of Object

this is a way to store common properties for many instances, if the values of these properties don’t change

Question 8

how to add property to prototype

Answer 8

Object.prototype.property = value;

define this outside of the object constructor;

Question 9

Own properties are defined _____. And prototype properties are defined _____

Answer 9

directly on the object instance itself

on the prototype

Question 10

the constructor property of an object is ____

Answer 10

is a reference to the constructor function that created the instance

Question 11

The advantage of the constructor property is that it’s possible to ____

Answer 11

check for this property to find out what kind of object it is

it can help determine if candidate belongs in a group, if their constructor refers to a particular super class/object (Crow > Bird)

it’s generally better to use the instanceof method to check the type of an object.

Question 12

How to add prototype properties at scale, not 1 by 1

Answer 12

set the prototype to a new object that already contains the properties

Bird.prototype = {
  numLegs: 2, 
  eat: function() {
    console.log("nom nom nom");
  },
  describe: function() {
    console.log("My name is " + this.name);
  }
};

Question 13

There is one crucial side effect of manually setting the prototype to a new object:

Answer 13

It erases the constructor property

Question 14

To fix the issue of erasing the constructor property when manually setting the prototype to a new object

Answer 14

remember to define the constructor property within that prototype object

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); 
  }
};

Question 15

isPrototypeOf method:

Answer 15

When called on the original object, with the instance in parenthesis, it returns true if the instance belongs to the original object

Bird.prototype.isPrototypeOf(duck);
// returns true

Question 16

The prototype of a prototype is…

Answer 16

Object.prototype

Question 17

In a prototype chain, Bird is the ____ for duck, while duck is the ____. Object is a ___ for both Bird and duck. Object is a ____ for all objects in JavaScript.

Answer 17

supertype, subtype, supertype, supertype

Therefore, any object can use the hasOwnProperty method.

Question 18

Create an abstraction of a supertype that stores just the common properties for its subtypes

Answer 18

function Animal {};

Animal.prototype = {
constructor: Animal,
someFunc: function(){
//do stuff
}}

// we haven’t got to inheritance yet though

Question 19

Inherit Behaviors from a Supertype

Answer 19

let animal = Object.create(Animal.prototype); //better way to create a new instance based on Animal

Question 20

Set the Child’s Prototype to an Instance of the Parent

Answer 20

//then give it to the specific animal's prototype
Bird.prototype = Object.create(Animal.prototype);

Question 21

When an object inherits its prototype from another object, it also inherits the supertype’s ____

Answer 21

constructor property.

function Bird() { }
Bird.prototype = Object.create(Animal.prototype);
let duck = new Bird();
duck.constructor // function Animal(){...}

Question 22

manually set Bird’s constructor property to the Bird object (instead of the supertype Animal) – code:

Answer 22

Bird.prototype.constructor = Bird;

duck.constructor // function Bird(){…}

Question 23

A constructor function that inherits its prototype object from a supertype constructor function _____ its own methods

Answer 23

can still have

Dog.prototype.property = function() {//do shit}

Question 24

Override Inherited Methods

Answer 24

just write over the subtypes prototype with the same method name and give it a different definition

Question 25

Inheritance does not work well for ____

Answer 25

unrelated objects like Bird and Airplane. They can both fly, but a Bird is not a type of Airplane and vice versa.

Question 26

A mixin allows

Answer 26

other objects to use a collection of functions. For unrelated objects, it's better to use mixins. ``` let flyMixin = function(obj) { obj.fly = function() { console.log("Flying, wooosh!"); } }; ```

Question 27

object's property is considered public if

Answer 27

it can be accessed and changed outside of object's definition

Question 28

The simplest way to make this public property private is by

Answer 28

creating a variable within the constructor function ``` function Bird() { let hatchedEgg = 10; // private variable } ```

Question 29

In JavaScript, a function always has access to the context in which it was created. This is called

Answer 29

closure

Question 30

Understand the Immediately Invoked Function Expression (IIFE)

Answer 30

``` (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.

Question 31

An immediately invoked function expression (IIFE) is often used to __

Answer 31

group related functionality into a single object or module. We can group mixins into a module as follows: ``` let motionModule = (function () { return {//mixin 1 glideMixin: function(obj) { obj.glide = function() { console.log("Gliding on the water"); }; }, //mixin 2 flyMixin: function(obj) { obj.fly = function() { console.log("Flying, wooosh!"); }; } } })(); // The two parentheses cause the function to be immediately executed ```