###giraffeMaker

var giraffe = {};

giraffe.name = name;

giraffe.height = height;

console.log('Hello, my name is ' + this.name + ', it is nice to meet you.');

};

this.hunger -= this.height;

} else {

console.log(this.name + " is not hungry.");

The first step will be creating some sort of maker function.

var theThingToBeMade = {};

theThingToBeMade.ownValue = value;

console.log("I have my own Value! Let it be known as " + theThingToBeMade.ownValue + "!");

};

The code in the previous maker function creates a new method .shout() for each thing that it creates, attaching this new function to each instance. What are we really trying to do here? Do we want each thing to have a new method of its own? Wouldn't it be cool if they could just share one function which they can inherit from being a thing?

var theThingToBeMade = {};

theThingToBeMade.ownValue = value;

theThingToBeMade.shout = shout;

return theThingToBeMade;

};

console.log("I have my own Value! Let it be known as " + this.ownValue + "!");

};

If we move the functionality outside of the maker function, we lose our previous way of referring to the created object, which was something like this.

theThingToBeMade = {};

theThingToBeMade.ownValue = value;

//This assigns a property ownValue to the object. We can refer to it within the two brackets that wrap the maker function.

1. It refers to what is to the left of the dot at calltime.

2. It's magical.

console.log(this.ownValue);

};

when you run newThing.shout(), this refers to newThing, as it is to the left of the dot at calltime.

- JavaScript would interpret this instance of the function call like:

console.log(newThing.ownValue);

};

when you run thatOtherThing.shout(), this refers to thatOtherThing.

thatOtherThing.shout(); // "I might not be the thing you wanted."

newThing.shout(); // "I am a thing!"

Using the keyword this allows us to refer to the particular instance of the class that we intend to within the shared function.

###Sharing functions using extend() - step 2:

copyTo[property] = copyFrom[property];

}

};

A prototype allows you to share methods and properties among class members. How this works more precisely is that once you set up a prototype chain, or delegate to a prototype. Any failed lookup on an object will be delegated to its prototype which will be checked for what was looked up on the object. The idea of using a prototype is to have any shared properties or methods on the prototype, allowing all class members to use them. The only property that should stay in the maker function would be one that changes or has a specific value for each instance.

var thingToBeMade = Object.create(maker.stuffAllThingsShouldHave);

thingToBeMade.ownValue = value;

maker.stuffAllThingsShouldHave = {

};

You would use 'new' when creating another instance of the class. When creating objects using Pseudo-Classical we need to use a maker function which has more specific rules.

this.ownValue = value;

};

var newThing = new Thing(1);

var otherThing = new Thing(100);

Here is how the interpreter sees the same function as it is run in constructor mode:

var newThing = Object.create(Thing.prototype);

this = newThing;

this.ownValue = value;

var protoThing = Thing(10);

this.ownValue = 10;

};