method in class constructor vs prototype

Given a class, there are two common ways to define a method for it.
function Calculator() {
this.sum = function (a, b) {
return a + b;
};
}
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); // 3

Differences

  1. 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.
  2. 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 () {
// A big function here
};
this.anotherBigFunction = function () {
// ...
};
}
versus
function Foo() {}
Foo.prototype.bigFunction = function() {
...
}
Foo.prototype.anotherBigFunction = function() {
...
}
The latter looks more readable and convenient.

See also