JavaScript OOP in NodeJS: how?

JavaScript OOP in NodeJS: how?

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() {
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() {}

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?)
here is an example in JsFiddle please provide feedback.
function inheritPrototype(childObject, parentObject) {
var copyOfParent = Object.create(parentObject.prototype)
copyOfParent.constructor = childObject
childObject.prototype = copyOfParent

function Canvas (id) { = id
this.shapes = {} //instead of array?
console.log(“Canvas constructor called “+id)
Canvas.prototype = {
constructor: Canvas
, getId: function() {
, getShape: function(shapeId) {
return this.shapes[shapeId]
, getShapes: function() {
return this.shapes
, addShape: function (shape) {
this.shapes[shape.getId()] = shape
, removeShape: function (shapeId) {
var shape = this.shapes[shapeId]
if (shape)
delete this.shapes[shapeId]
return shape

function Shape(id) { = id
this.size = { width: 0, height: 0 }
console.log(“Shape constructor called “+id)
Shape.prototype = {
constructor: Shape
, getId: function() {
, getSize: function() {
return this.size
, setSize: function (size) {
this.size = size

function Square(id, otherSuff) {, id) //same as Shape.prototype.constructor.apply( this, arguments ); ?
this.stuff = otherSuff
console.log(“Square constructor called “+id)
inheritPrototype(Square, Shape)
Square.prototype.getSize = function() { //override
return this.size.width

function ComplexShape(id) {, id)
this.frame = null
console.log(“ComplexShape constructor called “+id)
inheritPrototype(ComplexShape, Shape)
ComplexShape.prototype.getFrame = function() {
return this.frame
ComplexShape.prototype.setFrame = function(frame) {
this.frame = frame

function Frame(id) { = id
this.length = 0
Frame.prototype = {
constructor: Frame
, getId: function() {
, getLength: function() {
return this.length
, setLength: function (length) {
this.length = length

var aCanvas = new Canvas(“c1”)
var anotherCanvas = new Canvas(“c2”)
console.log(“aCanvas: “+ aCanvas.getId())

var aSquare = new Square(“s1”, {})
aSquare.setSize({ width: 100, height: 100})
console.log(“square overridden size: “+aSquare.getSize())

var aComplexShape = new ComplexShape(“supercomplex”)
var aFrame = new Frame(“f1”)

console.log(“Shapes in aCanvas: “+Object.keys(aCanvas.getShapes()).length)

console.log(“Shapes in aCanvas: “+Object.keys(aCanvas.getShapes()).length)
console.log(“Shapes in anotherCanvas: “+Object.keys(anotherCanvas.getShapes()).length)

console.log(aSquare instanceof Shape)
console.log(aComplexShape instanceof Shape)


Solution 1:

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() {

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();
 console.log(a[0]) //3;

Solution 2:

As Node.js community ensure new features from the JavaScript ECMA-262 specification are brought to Node.js developers in a timely manner.

You can take a look at JavaScript classes. MDN link to JS classes
In the ECMAScript 6 JavaScript classes are introduced, this method provide easier way to model OOP concepts in Javascript.

Note : JS classes will work in only strict mode.

Below is some skeleton of class,inheritance written in Node.js ( Used Node.js Version v5.0.0 )

Class declarations :

'use strict'; 
class Animal{

 constructor(name){ = name ;

    console.log('Name is :'+;

var a1 = new Animal('Dog');

Inheritance :

'use strict';
class Base{

 // methods definitions go here

class Child extends Base{
 // methods definitions go here

var childObj = new Child();

Solution 3:

I suggest to use the inherits helper that comes with the standard util module:

There is an example of how to use it on the linked page.

Solution 4:

This is the best video about Object-Oriented JavaScript on the internet:

The Definitive Guide to Object-Oriented JavaScript

Watch from beginning to end!!

Basically, Javascript is a Prototype-based language which is quite different than the classes in Java, C++, C#, and other popular friends.
The video explains the core concepts far better than any answer here.

With ES6 (released 2015) we got a “class” keyword which allows us to use Javascript “classes” like we would with Java, C++, C#, Swift, etc.

Screenshot from the video showing how to write and instantiate a Javascript class/subclass:
enter image description here

Solution 5:

In the Javascript community, lots of people argue that OOP should not be used because the prototype model does not allow to do a strict and robust OOP natively. However, I don’t think that OOP is a matter of langage but rather a matter of architecture.

If you want to use a real strong OOP in Javascript/Node, you can have a look at the full-stack open source framework Danf. It provides all needed features for a strong OOP code (classes, interfaces, inheritance, dependency-injection, …). It also allows you to use the same classes on both the server (node) and client (browser) sides. Moreover, you can code your own danf modules and share them with anybody thanks to Npm.