JavaScript OOP em NodeJS: como?

Estou acostumado com o OOP clássico como em Java.

Quais são as melhores práticas para fazer OOP em JavaScript usando NodeJS?

Cada classe é um arquivo com module.export?

Como criar classes?

this.Class = function() {
    //constructor?
    var privateField = ""
    this.publicField = ""
    var privateMethod = function() {}
    this.publicMethod = function() {} 
}

vs. (nem tenho certeza se está correto)

this.Class = {
    privateField: ""
    , privateMethod: function() {}

    , return {
        publicField: ""
        publicMethod: function() {}
    }
}

vs.

this.Class = function() {}

this.Class.prototype.method = function(){}

...

Como funcionaria a herança?

Existem módulos específicos para implementar OOP em NodeJS?

Estou descobrindo milhares de maneiras diferentes de criar coisas que se assemelham ao OOP ... mas não tenho ideia de qual é a maneira mais usada / prática / limpa.

Pergunta bônus : qual é o "estilo OOP" sugerido para usar com o MongooseJS? (pode um documento MongooseJS ser visto como uma classe e um modelo usado como uma instância?)

EDITAR

aqui está um exemplo em JsFiddle , forneça feedback.

//http://javascriptissexy.com/oop-in-javascript-what-you-need-to-know/
function inheritPrototype(childObject, parentObject) {
    var copyOfParent = Object.create(parentObject.prototype)
    copyOfParent.constructor = childObject
    childObject.prototype = copyOfParent
}

//example
function Canvas (id) {
    this.id = id
    this.shapes = {} //instead of array?
    console.log("Canvas constructor called "+id)
}
Canvas.prototype = {
    constructor: Canvas
    , getId: function() {
        return this.id
    }
    , 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) {
    this.id = id
    this.size = { width: 0, height: 0 }
    console.log("Shape constructor called "+id)
}
Shape.prototype = {
    constructor: Shape
    , getId: function() {
        return this.id
    }
    , getSize: function() {
        return this.size
    }
    , setSize: function (size)  {
        this.size = size
    }
}

//inheritance
function Square(id, otherSuff) {
    Shape.call(this, 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) {
    Shape.call(this, 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) {
    this.id = id
    this.length = 0
}
Frame.prototype = {
    constructor: Frame
    , getId: function() {
        return this.id
    }
    , getLength: function() {
        return this.length
    }
    , setLength: function (length)  {
        this.length = length
    }
}

/////run
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")
aComplexShape.setFrame(aFrame)
console.log(aComplexShape.getFrame())

aCanvas.addShape(aSquare)
aCanvas.addShape(aComplexShape)
console.log("Shapes in aCanvas: "+Object.keys(aCanvas.getShapes()).length)

anotherCanvas.addShape(aCanvas.removeShape("supercomplex"))
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)

Este é um exemplo que funciona fora da caixa. Se você quiser menos "hacky", deve usar uma biblioteca de herança ou algo parecido.

Bem, em um arquivo animal.js você escreveria:

var method = Animal.prototype;

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

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

module.exports = Animal;

Para usá-lo em outro arquivo:

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

var john = new Animal(3);

Se você quiser uma "subclasse", dentro de 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;

Além disso, você pode considerar "empréstimo de método" em vez de herança vertical. Você não precisa herdar de uma "classe" para usar seu método em sua classe. Por exemplo:

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

 }

 method.add = Array.prototype.push;

 ...

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

Como a comunidade Node.js garante que novos recursos da especificação JavaScript ECMA-262 sejam trazidos aos desenvolvedores Node.js em tempo hábil.

Você pode dar uma olhada nas classes JavaScript . Link MDN para classes JS Nas classes ECMAScript 6 JavaScript são introduzidas, este método fornece uma maneira mais fácil de modelar conceitos OOP em Javascript.

Nota : as classes JS funcionarão apenas no modo estrito .

Abaixo está algum esqueleto de classe, herança escrita em Node.js (versão Node.js usada v5.0.0 )

Declarações de classe:

'use strict'; 
class Animal{

 constructor(name){
    this.name = name ;
 }

 print(){
    console.log('Name is :'+ this.name);
 }
}

var a1 = new Animal('Dog');

Herança:

'use strict';
class Base{

 constructor(){
 }
 // methods definitions go here
}

class Child extends Base{
 // methods definitions go here
 print(){ 
 }
}

var childObj = new Child();

Sugiro usar o inheritsauxiliar que vem com o utilmódulo padrão : http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor

Há um exemplo de como usá-lo na página vinculada.

Este é o melhor vídeo sobre JavaScript orientado a objetos na Internet:

O guia definitivo para JavaScript orientado a objetos

Assista do começo ao fim !!

Basicamente, Javascript é uma linguagem baseada em protótipo que é bastante diferente das classes em Java, C ++, C # e outros amigos populares. O vídeo explica os conceitos básicos muito melhor do que qualquer resposta aqui.

Com o ES6 (lançado em 2015), obtivemos uma palavra-chave "class" que nos permite usar "classes" Javascript como faríamos com Java, C ++, C #, Swift, etc.

Captura de tela do vídeo mostrando como escrever e instanciar uma classe / subclasse Javascript:

Na comunidade Javascript, muitas pessoas argumentam que OOP não deve ser usado porque o modelo de protótipo não permite fazer um OOP rígido e robusto nativamente. No entanto, não acho que OOP seja uma questão de linguagem, mas sim uma questão de arquitetura.

Se você deseja usar um OOP realmente forte em Javascript / Node, pode dar uma olhada no framework de código aberto Danf full stack . Ele fornece todos os recursos necessários para um código OOP forte (classes, interfaces, herança, injeção de dependência, ...). Ele também permite que você use as mesmas classes nos lados do servidor (nó) e do cliente (navegador). Além disso, você pode codificar seus próprios módulos danf e compartilhá-los com qualquer pessoa, graças ao Npm.

Se você está trabalhando por conta própria e deseja a coisa mais próxima de OOP como encontraria em Java, C # ou C ++, consulte a biblioteca javascript, CrxOop. CrxOop fornece sintaxe um tanto familiar para desenvolvedores Java.

Apenas tome cuidado, a OOP do Java não é a mesma encontrada no Javascript. Para obter o mesmo comportamento do Java, use as classes do CrxOop, não as estruturas do CrxOop, e certifique-se de que todos os seus métodos sejam virtuais. Um exemplo da sintaxe é,

crx_registerClass("ExampleClass", 
{ 
    "VERBOSE": 1, 

    "public var publicVar": 5, 
    "private var privateVar": 7, 

    "public virtual function publicVirtualFunction": function(x) 
    { 
        this.publicVar1 = x;
        console.log("publicVirtualFunction"); 
    }, 

    "private virtual function privatePureVirtualFunction": 0, 

    "protected virtual final function protectedVirtualFinalFunction": function() 
    { 
        console.log("protectedVirtualFinalFunction"); 
    }
}); 

crx_registerClass("ExampleSubClass", 
{ 
    VERBOSE: 1, 
    EXTENDS: "ExampleClass", 

    "public var publicVar": 2, 

    "private virtual function privatePureVirtualFunction": function(x) 
    { 
        this.PARENT.CONSTRUCT(pA);
        console.log("ExampleSubClass::privatePureVirtualFunction"); 
    } 
}); 

var gExampleSubClass = crx_new("ExampleSubClass", 4);

console.log(gExampleSubClass.publicVar);
console.log(gExampleSubClass.CAST("ExampleClass").publicVar);

O código é javascript puro, sem transpilar. O exemplo é retirado de vários exemplos da documentação oficial.