method in class constructor vs prototype
Given a class, there are two common ways to define a method for it.
- Define the method in the class constructor
function Calculator() {
this.sum = function (a, b) {
return a + b;
};
}
- Or define the method in the class prototype:
function Calculator() {}
Calculator.prototype.sum = function (a, b) {
return a + b;
};
Both approaches produce the same result when the method is invoked by a class instance:
const calc = new Calculator();
calc.sum(1, 2);
Differences
-
In the first approach, the method has to be created every time we create a new instance of the class. The second approach, on the other hand, creates the method once and share it for all instances of the class.
That's being said, the second approach is more efficient, and requires less memory than the first one.
-
The method created via prototype can be extended and overridden by the sub class.
Good practice
The first approach could create a huge constructor function that consists of logic of other functions.
Consider the following huge constructor:
function Foo() {
this.bigFunction = function () {
};
this.anotherBigFunction = function () {
};
}
versus
function Foo() {}
Foo.prototype.bigFunction = function() {
...
}
Foo.prototype.anotherBigFunction = function() {
...
}
The latter looks more readable and convenient.
See also