Javascript What is constructor function

 

When new Vehicle() is called, JavaScript does four things:

 

1. It creates a new object.

2. It sets the constructor property of the object to Vehicle.

3. It sets up the object to delegate to Vehicle.prototype.

4. It calls Vehicle() in the context of the new object.

  

The result of new Vehicle() is this new object.

 

 

This is nothing special, just a fresh, new object: {}.

 

 

This means two things:

vehicle.constructor == Vehicle

// true vehicle instanceof Vehicle // true

 

This isn’t an ordinary property. It won’t show up if you enumerate the properties of the object. Also, you can try to set constructor, but you’ll just set a normal property on top of this special one. To wit:

 

vehicle; // {}

var FuzzyBear = function FuzzyBear() { };

vehicle.constructor = FuzzyBear; vehicle; //

{ constructor: function FuzzyBear() }

vehicle.constructor == FuzzyBear; // true

vehicle instanceof FuzzyBear // false

vehicle instanceof Vehicle // true

 

The underlying, built in constructor property is something you can’t set manually. It can only be set for you, as part of construction with the new keyword.

 

 

Now it gets interesting.

 

A function is just a special kind of object, and like any object a function can have properties. Functions automatically get a property called prototype, which is just an empty object. This object gets some special treatment.

 

When an object is constructed, it inherits all of the properties of its constructor’s prototype. I know, it’s a brainful. Here.

 

Vehicle.prototype.wheelCount = 4;

var vehicle = new Vehicle;

vehicle.wheelCount; // 4

 

The Vehicle instance picked up the wheelCount from Vehicle‘s prototype

 

Now this “inheritance” is more than simply copying properties to the new objects. The object is set up to delegate any properties which haven’t been explicitly set up to its constructor’s prototype. That means that we can change the prototype later, and still see the changes in the instance.

 

Vehicle.prototype.wheelCount = 6;

vehicle.wheelCount; // 6

 

But if we like, we can always override it.

 

vehicle.wheelCount = 8;

vehicle.wheelCount // 8 (new Vehicle()).wheelCount // 6;

 

We can do the same thing with methods. After all, a method is just a function assigned to a property. Check it.

 

Vehicle.prototype.go = function go()

{

return "Vroom!"

};

vehicle.go(); // "Vroom!"

 

4. It calls Vehicle() in the context of the new object.

 

Finally, the constructor function itself is called. Inside the function, this is set to the object we’re constructing. (Why? Because that’s what Java does.) So,

 

var Vehicle = function Vehicle(color)

{

this.constructor; //

function Vehicle() this.color = color;

}

(new Vehicle("tan")).color; // "tan"

 

Side note: Above, I said the use of the new keyword returned the constructed object. This is correct unless the constructor returns something explicitly. Then that object is returned, and the constructed object is just dropped. But really. JavaScript slaves over a hot CPU to create this object for you and then you just throw it away? Rude. And confusing to people who use your constructor. So unless you have a really good reason, don’t return anything from constructor functions.

 

 

Given this tool, here’s one way (the intended way, but not the only way) to implement something like classes in JavaScript.

 

// Class definition /

constructor var Vehicle = function Vehicle(color)

{ // Initialization

this.color = color; }

// Instance methods

Vehicle.prototype = {

go: function go()

{

return "Vroom!"; } }

 

 

This “pseudoclassical” style doesn’t have an exact way to make subclasses, but it comes close. We can set the prototype of our “subclass” to an instance of the “superclass”.

 

var Car = function Car() {};

Car.prototype = new Vehicle("tan");

Car.prototype.honk = function honk()

{

return "BEEP!" };

var car = new Car();

car.honk(); // "BEEP!"

car.go(); // "Vroom!"

car.color; // "tan"

car instanceof Car; // true

car instanceof Vehicle; // true

 

Now, there’s a problem here. The Vehicle constructor only gets called once, to set up Car‘s prototype. We need to give it a color there. We can’t make different cars have different colors, which is not ideal. Some JavaScript frameworks have gotten around this by defining their own implementations of classes.

 

And for my last trick…

 

Sometimes you don’t want a notion of classes. Sometimes you just want one object to inherit the properties of another (but be able to override them). This is how most prototype-based languages work, but not JavaScript. At least, not without a little massaging.

 

This function lets us accomplish it. It’s been tossed around for a long time and is sometimes called “create” and sometimes “clone” and sometimes other things.

 

function create(parent)

{

var F = function() {};

F.prototype = parent;

return new F();

}

var masterObject = {a: "masterObject value"}

var object1 = create(masterObject);

var object2 = create(masterObject);

var object3 = create(masterObject);

var object3.a = "overridden value";

object1.a; // "masterObject value"

object2.a; // "masterObject value"

object3.a; // "overridden value"

masterObject.a = "new masterObject value"

object1.a; // "new masterObject value"

object2.a; // "new masterObject value"

object3.a; // "overridden value"

 

You said a mouthful.

 

The JavaScript prototype chain is a little different than how most languages work, so it can be tricky understand. It doesn’t make it any easier when JavaScript gets syntax that makes it looks more like other languages, like inheriting Java’s new operator. But if you know what you’re doing, you can do some crazy-cool things with it.