Javascript What is constructor function

Question

tell me when js function will be called as constructor function ?

if we write a simple js function then it will be called as constructor function ?

function myFunction(a, b) {
return a * b;
}
var x = myFunction(4, 3);

so tell me myFunction() will be consider as constructor function ? if no then describe the reason.

tell me why below js function is consider as constructor function ?

function person(first, last, age, eye) {
this.firstName = first;
this.lastName = last;
this.age = age;
this.eyeColor = eye;
}
var myFather = new person("John", "Doe", 50, "blue");
var myMother = new person("Sally", "Rally", 48, "green");

when new keyword will be used to call js function then it will be consider as constructor function ?

please guide me. thanks

Manikandan Murugesan · Answer

What happens when a constructor is called? 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. 1. It creates the new object. This is nothing special just a fresh new object: {}. 2. It sets the constructor property of the object to Vehicle. 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. 3. It sets up the object to delegate to Vehicle.prototype. 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. Putting it all together 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!; } } “Subclassing” 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.

tri_inn · Answer

you are good googler and copier. i found that link just after posting this question from where you copy the answer. good try