tutorial - OOP de JavaScript en NodeJS: ¿cómo?

node js tutorial

Question

Estoy acostumbrado al OOP clásico 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?

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

Estoy encontrando mil 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 extra : ¿cuál es el "estilo OOP" sugerido para usar con MongooseJS? (¿Se puede ver un documento de MongooseJS como una Clase y un modelo utilizado como instancia?)

EDITAR

aquí hay un ejemplo en JsFiddle por favor brinde 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)

Answer 1

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

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

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

A continuación se muestra un esqueleto de clase, herencia escrita en Node.js (Versión utilizada 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();

Answer 2

En la comunidad de Javascript, muchas personas argumentan que OOP no debería usarse porque el prototipo del modelo no permite hacer un OOP estricto y robusto de forma nativa. Sin embargo, no creo que OOP sea una cuestión de langage sino más bien una cuestión de arquitectura.

Si desea utilizar un POO real fuerte 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 fuerte (clases, interfaces, herencia, inyección de dependencia, ...). También le permite usar las mismas clases en los lados del servidor (nodo) y del cliente (navegador). Además, puedes codificar tus propios módulos de danf y compartirlos con cualquier persona gracias a Npm.

Answer 3

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

La guía definitiva de JavaScript orientado a objetos

Mira de principio a fin !!

Básicamente, Javascript es un lenguaje Prototype-based que es bastante diferente de las clases en 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 instancias de una clase / subclase de Javascript: Prototype-based

Answer 4

Este es un ejemplo que funciona de la caja. Si desea menos "hacky", debe usar la biblioteca de herencia o tal.

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 quieres una "subclase", entonces 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 "Método de endeudamiento" en lugar de herencia vertical. No necesita heredar de una "clase" para usar su método en su 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;

Answer 5

Sugiero usar el helper inherits que viene con el módulo de util 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.