Question

Consider the following code:

function Robot(weapon) {
    this.weapon = weapon;
    this.fire = function() {
        alert('Firing ' + this.weapon + 'projectile.');
    };
}

var gunRobot = new Robot('gun');

vs.

function makeRobot(weapon) {
    return {
        weapon: weapon,
        fire: function() {
            alert('Firing ' + this.weapon + 'projectile.');
        }
    };
}

var laserRobot = makeRobot('laser');

So, if I understood right, the main difference between these two is that in the first example, gunRobot has a constructor property which points to Robot, whereas in the second example, laserRobot has a construtor property which points to Object. Both don’t add anything to their prototype, right?

Now, if I change the first example to:

function Robot(weapon) {
    this.weapon = weapon;
}

Robot.prototype.fire = function() {
        alert('Firing ' + this.weapon + 'projectile.');
};

var gunRobot = new Robot('gun');

gunRobot’s constructor property points to the Robot constructor, whose prototype property has a property fire. Now, if I call

gunRobot.fire();

as, gunRobot doesn not have a fire property, the next prototype up in the prototype chain is visited and checked for a fire property, right?

I’m mainly a Java programmer, so it’s quite hard to wrap my head around JS notion of object-orientation :-).

Answer 1

Really, really close, but considering this sentence…

“gunRobot’s constructor property points to the Robot constructor, whose prototype property has a property fire.”

…it seems that you may think that it is via the constructor property that gunRobot will access its prototype object.

That wouldn’t be correct. The gunRobot object doesn’t have a property of its own called constructor, but that property is actually a member of the prototype object itself.

The way that the prototype object is referenced is internal and therefore implicit.

This means…

• You could shadow the constructor property on the gunRobot object, and still have your implicit reference to the prototype object

• You could delete the constructor property from the prototype object, and the prototype chain would be unaffected

• If you entirely replace the prototype object of the constructor, any objects that have already been created from the constructor do not see the change. Their prototype object reference is permanent. Only new objects would have the internal reference to the new prototype object.

---

And with respect to this question…

“Both don’t add anything to their prototype, right?”

…you’re right that nothing has been added to the prototype object of either object. (Of course, the default Object.prototype object has some default properties.)

---

• gunRobot —-> Robot.prototype (empty object)

• Robot.prototype —-> Object.prototype

• Object.prototype —-> null

---

• laserRobot —-> Object.prototype

• Object.prototype —-> null