JavaScript OOP en NodeJS: ¿cómo?

Estoy acostumbrado a la POO clásica como en Java.

¿Cuáles son las mejores prácticas para hacer OOP en JavaScript usando NodeJS?

Cada clase es un archivo con module.export?

¿Cómo crear clases?

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

vs. (ni siquiera estoy seguro de que sea correcto)

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

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

vs.

this.Class = function() {}

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

...

¿Cómo funcionaría la herencia?

¿Existen módulos específicos para implementar OOP en NodeJS?

Estoy encontrando mil formas diferentes de crear cosas que se parezcan a POO ... pero no tengo ni idea de cuál es la forma más utilizada / práctica / limpia.

Pregunta adicional : ¿cuál es el "estilo OOP" sugerido para usar con MongooseJS? (¿se puede ver un documento MongooseJS como una clase y un modelo como instancia?)

EDITAR

aquí hay un ejemplo en JsFiddle, por favor envíe sus comentarios.

//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 es un ejemplo que funciona fuera de la caja. Si quieres menos "hacky", debes usar la biblioteca de herencia o algo así.

Bueno, en un archivo animal.js escribirías:

var method = Animal.prototype;

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

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

module.exports = Animal;

Para usarlo en otro archivo:

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

var john = new Animal(3);

Si desea una "subclase", 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;

También puede considerar el "Método de préstamo" en lugar de la herencia vertical. No necesitas heredar de una "clase" para usar su método en tu clase. Por ejemplo:

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

 }

 method.add = Array.prototype.push;

 ...

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

Como la comunidad de Node.js, se asegura de que las nuevas características de la especificación JavaScript ECMA-262 lleguen a los desarrolladores de Node.js de manera oportuna.

Puedes echar un vistazo a las clases de JavaScript . Enlace MDN a clases JS En las clases de JavaScript ECMAScript 6 se introducen, este método proporciona una manera más fácil de modelar conceptos de POO en Javascript.

Nota : Las clases JS funcionarán solo en modo estricto .

A continuación se muestra el esqueleto de la clase, la herencia escrita en Node.js (versión usada de Node.js v5.0.0 )

Declaraciones de clase:

'use strict'; 
class Animal{

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

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

var a1 = new Animal('Dog');

Herencia :

'use strict';
class Base{

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

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

var childObj = new Child();

Sugiero usar el inheritsayudante que viene con el utilmódulo estándar : http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor

Hay un ejemplo de cómo usarlo en la página vinculada.

Este es el mejor video sobre JavaScript orientado a objetos en Internet:

La guía definitiva para JavaScript orientado a objetos

¡Mira de principio a fin!

Básicamente, Javascript es un lenguaje basado en prototipos que es bastante diferente a las clases de Java, C ++, C # y otros amigos populares. El video explica los conceptos básicos mucho mejor que cualquier respuesta aquí.

Con ES6 (lanzado en 2015) obtuvimos una palabra clave de "clase" que nos permite usar "clases" de Javascript como lo haríamos con Java, C ++, C #, Swift, etc.

Captura de pantalla del video que muestra cómo escribir y crear una instancia de una clase / subclase de Javascript:

En la comunidad de Javascript, mucha gente argumenta que la POO no debería usarse porque el modelo prototipo no permite hacer una POO estricta y robusta de forma nativa. Sin embargo, no creo que la POO sea una cuestión de idioma, sino más bien una cuestión de arquitectura.

Si desea utilizar una POO realmente sólida en Javascript / Node, puede echar un vistazo al marco de código abierto de pila completa Danf . Proporciona todas las características necesarias para un código OOP sólido (clases, interfaces, herencia, inyección de dependencia, ...). También le permite utilizar las mismas clases en el lado del servidor (nodo) y del cliente (navegador). Además, puede codificar sus propios módulos danf y compartirlos con cualquiera gracias a Npm.

Si está trabajando por su cuenta y desea lo más parecido a OOP como lo encontraría en Java o C # o C ++, consulte la biblioteca de javascript, CrxOop. CrxOop proporciona una sintaxis algo familiar para los desarrolladores de Java.

Solo tenga cuidado, la POO de Java no es la misma que se encuentra en Javascript. Para obtener el mismo comportamiento que en Java, use las clases de CrxOop, no las estructuras de CrxOop, y asegúrese de que todos sus métodos sean virtuales. Un ejemplo de sintaxis es,

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);

El código es javascript puro, sin transpiración. El ejemplo se toma de varios ejemplos de la documentación oficial.