JavaScript OOP in NodeJS: how?

Question

I am used to the classical OOP as in Java. What are the best practices to do OOP in JavaScript using NodeJS? Each Class is a file with `module.export`? How to create Classes? ``` this.Class = function() { //constructor? var privateField = "" this.publicField = "" var privateMethod = function() {} this.publicMethod = function() {} } ``` vs. (I am not even sure it is correct) ``` this.Class = { privateField: "" , privateMethod: function() {} , return { publicField: "" publicMethod: function() {} } } ``` vs. ``` this.Class = function() {} this.Class.prototype.method = function(){} ... ``` How would inheritance work? Are there specific modules for implementing OOP in NodeJS? I am finding a thousand different ways to create things that resemble OOP.. but I have no clue what is the most used/practical/clean way. Bonus question: what is the suggested "OOP style" to use with MongooseJS? (can a MongooseJS document be seen as a Class and a model used as an instance?) EDIT here is an example in…

Accepted Answer

This is an example that works out of the box. If you want less "hacky", you should use inheritance library or such.

Well in a file animal.js you would write:

```
var method = Animal.prototype;

function Animal(age) {
    this._age = age;
}

method.getAge = function() {
    return this._age;
};

module.exports = Animal;
```

To use it in other file:

```
var Animal = require("./animal.js");

var john = new Animal(3);
```

If you want a "sub class" then inside mouse.js:

```
var _super = require("./animal.js").prototype,
    method = Mouse.prototype = Object.create( _super );

method.constructor = Mouse;

function Mouse() {
    _super.constructor.apply( this, arguments );
}
//Pointless override to show super calls
//note that for performance (e.g. inlining the below is impossible)
//you should do
//method.$getAge = _super.getAge;
//and then use this.$getAge() instead of super()
method.getAge = function() {
    return _super.getAge.call(this);
};

module.exports = Mouse;
```

Also you can consider "Method borrowing" instead of vertical inheritance. You don't need to inherit from a "class" to use its method on your class. For instance:

```
 var method = List.prototype;
 function List() {

}

method.add = Array.prototype.push;

...

var a = new List();
 a.add(3);
 console.log(a[0]) //3;
```

JavaScript OOP in NodeJS: how?

Solution

Problem