node.js - NodeJS中的JavaScript OOP:怎么样?

我习惯于Java中的经典OOP。

使用NodeJS在JavaScript中进行OOP的最佳实践是什么?

每个类都是一个module.export的文件?

如何创建类?

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

vs.(我甚至不确定它是否正确)

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

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

this.Class = function() {}

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

...

继承如何工作?

是否有在NodeJS中实现OOP的特定模块?

我发现了一千种不同的方法来创造类似于OOP的东西..但我不知道最常用/实用/干净的方式是什么。

奖金问题:与MongooseJS一起使用的建议“OOP风格”是什么? (Mongoose JS文档可以被视为一个类和一个用作实例的模型吗?)

编辑

这里是JsFiddle中的一个例子,请提供反馈。

//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)
fusio asked 2019-07-31T05:07:04Z
5个解决方案
108 votes

这是一个开箱即用的示例。 如果你想减少“hacky”,你应该使用继承库等。

好吧,在文件animal.js中你会写:

var method = Animal.prototype;

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

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

module.exports = Animal;

要在其他文件中使用它:

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

var john = new Animal(3);

如果你想要一个“子类”,那么在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;

您也可以考虑“方法借用”而不是垂直继承。 您不需要从“类”继承以在您的类上使用其方法。 例如:

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

 }

 method.add = Array.prototype.push;

 ...

 var a = new List();
 a.add(3);
 console.log(a[0]) //3;
Esailija answered 2019-07-31T05:07:50Z
41 votes

Node.js社区确保将JavaScript ECMA-262规范中的新功能及时提供给Node.js开发人员。

你可以看看JavaScript类。 MDN链接到JS类在ECMAScript 6中引入了JavaScript类,该方法提供了在Javascript中模拟OOP概念的更简单方法。

Node:JS类只能在严格模式下工作。

下面是一些类的骨架,用Node.js编写的继承(Used Node.js Version v5.0.0)

类声明:

'use strict'; 
class Animal{

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

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

var a1 = new Animal('Dog');

继承:

'use strict';
class Base{

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

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

var childObj = new Child();
Piyush Sagar answered 2019-07-31T05:08:49Z
14 votes

我建议使用标准util模块附带的inherits帮助程序:[http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor]

有一个如何在链接页面上使用它的示例。

badsyntax answered 2019-07-31T05:09:21Z
9 votes

这是关于互联网上面向对象JavaScript的最佳视频:

面向对象JavaScript的权威指南

从头到尾观看!!

基本上,Javascript是一种基于Prototype的语言,它与Java,C ++,C#和其他流行朋友中的类完全不同。该视频解释了核心概念,远胜于此处的任何答案。

使用ES6(2015年发布),我们得到了一个“class”关键字,它允许我们像使用Java,C ++,C#,Swift等一样使用Javascript“类”。

显示如何编写和实例化Javascript类/子类的视频的屏幕截图:enter image description here

etayluz answered 2019-07-31T05:10:32Z
4 votes

在Javascript社区中,很多人认为不应该使用OOP,因为原型模型不允许本地执行严格且强大的OOP。 但是,我不认为OOP是一个问题,而是建筑问题。

如果你想在Javascript / Node中使用真正强大的OOP,你可以看看全栈开源框架Danf。 它为强大的OOP代码(类,接口,继承,依赖注入......)提供了所有必需的功能。 它还允许您在服务器(节点)和客户端(浏览器)端使用相同的类。 此外,您可以编写自己的danf模块并与任何人分享,这要归功于Npm。

Gnucki answered 2019-07-31T05:11:06Z
translate from https://stackoverflow.com:/questions/18188083/javascript-oop-in-nodejs-how