¿Es necesaria la OOP en las aplicaciones web de Node.js?

Estoy acostumbrado a la OOP 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 () {}

, regreso {
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 miles de formas diferentes de crear cosas que se parecen a OOP … pero no tengo 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 utilizado como una 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/
función heredarPrototipo (childObject, parentObject) {
var copyOfParent = Object.create (parentObject.prototype)
copyOfParent.constructor = childObject
childObject.prototype = copyOfParent
}

//ejemplo
función Canvas (id) {
this.id = id
this.shapes = {} // en lugar de array?
console.log (“Constructor de Canvas llamado” + id)
}
Canvas.prototype = {
constructor: lienzo
, getId: function () {
devuelve this.id
}
, getShape: function (shapeId) {
devuelve this.shapes [shapeId]
}
, getShapes: function () {
devuelve this.shapes
}
, addShape: function (forma) {
this.shapes [shape.getId ()] = forma
}
, removeShape: function (shapeId) {
var shape = this.shapes [shapeId]
si (forma)
eliminar this.shapes [shapeId]
forma de retorno
}
}

función Forma (id) {
this.id = id
this.size = {ancho: 0, altura: 0}
console.log (“Constructor de formas llamado” + id)
}
Shape.prototype = {
constructor: forma
, getId: function () {
devuelve this.id
}
, getSize: function () {
devolver este tamaño
}
, setSize: function (tamaño) {
this.size = tamaño
}
}

//herencia
función Square (id, otherSuff) {
Shape.call (this, id) // igual que Shape.prototype.constructor.apply (this, argumentos); ?
this.stuff = otherSuff
console.log (“Constructor cuadrado llamado” + id)
}
heredarPrototipo (cuadrado, forma)
Square.prototype.getSize = function () {// override
devuelve this.size.width
}

función ComplexShape (id) {
Shape.call (esto, id)
this.frame = null
console.log (“Constructor ComplexShape llamado” + id)
}
heredarPrototipo (ComplexShape, Shape)
ComplexShape.prototype.getFrame = function () {
devuelve this.frame
}
ComplexShape.prototype.setFrame = function (frame) {
this.frame = frame
}

marco de función (id) {
this.id = id
this.length = 0
}
Frame.prototype = {
constructor: marco
, getId: function () {
devuelve this.id
}
, getLength: function () {
devuelve this.length
}
, setLength: function (length) {
this.length = length
}
}

/////correr
var aCanvas = nuevo lienzo (“c1”)
var anotherCanvas = nuevo Canvas (“c2”)
console.log (“aCanvas:” + aCanvas.getId ())

var aSquare = nuevo cuadrado (“s1”, {})
aSquare.setSize ({ancho: 100, alto: 100})
console.log (“tamaño sobrescrito cuadrado:” + aSquare.getSize ())

var aComplexShape = new ComplexShape (“supercomplex”)
var aFrame = nuevo marco (“f1”)
aComplexShape.setFrame (aFrame)
console.log (aComplexShape.getFrame ())

aCanvas.addShape (aSquare)
aCanvas.addShape (aComplexShape)
console.log (“Formas en aCanvas:” + Object.keys (aCanvas.getShapes ()). length)

anotherCanvas.addShape (aCanvas.removeShape (“supercomplejo”))
console.log (“Formas en aCanvas:” + Object.keys (aCanvas.getShapes ()). length)
console.log (“Formas en anotherCanvas:” + Object.keys (anotherCanvas.getShapes ()). length)

console.log (una instancia cuadrada de Shape)
console.log (una instancia de ShapeComplexShape)

javascript node.js oop herencia mangosta

No, no necesitas aprender todos esos prototipos de herencia y cosas para trabajar con la herencia.

Muchos de mis compañeros de trabajo ni siquiera saben qué es el prototipo, pero aún envían toneladas de código nodejs.

Prototype es un mecanismo utilizado por javascript para admitir oops. No voy a decir aquí cómo y por qué, ya que este es un tema muy importante. y hay toneladas de material alrededor de esto en internet. Object.prototype

Pero para agregar a su pregunta, sí, se usa en grandes proyectos con escala. OOPs proporciona una manera mucho mejor para escalar su proyecto usando herencia y polimorfismo.

Si no se siente cómodo con el prototipo, puede usar la última versión de nodo con sintaxis ES6 que admita la notación de clase normal y amplíe el tipo de palabras clave para la herencia como lo hacemos en Java.

TypeScript admite clases y, finalmente, Node también lo hará, por lo que será necesario para cuando ES6 se convierta en la corriente principal.

Si necesario. En ES6 o posterior, debe aprender clases, objetos, importar, exportar y módulos js comunes.

Sí, mucho, oops está en todas partes. Los conceptos de Uy son muy necesarios en cualquier lenguaje de programación basado en la web en particular.

Sus aplicaciones son enormes.