JavaScript OOP in NodeJS: wie?

Ich bin an die klassische OOP wie in Java gewöhnt.

Was sind die Best Practices für OOP in JavaScript mit NodeJS?

Jede Klasse ist eine Datei mit module.export?

Wie erstelle ich Klassen?

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

(Ich bin mir nicht mal sicher, ob es richtig ist)

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

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

vs.

this.Class = function() {}

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

...

Wie würde die Vererbung funktionieren?

Gibt es spezielle Module zur Implementierung von OOP in NodeJS?

Ich finde tausend verschiedene Wege, um Dinge zu erschaffen, die OOP ähneln. Aber ich habe keine Ahnung, was der am häufigsten verwendete / praktische / saubere Weg ist.

Bonusfrage : Was ist der empfohlene "OOP-Stil" für MongooseJS? (Kann ein MongooseJS-Dokument als Klasse und als Modell als Instanz verwendet werden?)

BEARBEITEN

Hier ist ein Beispiel in JsFiddle. Bitte geben Sie 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)

Dies ist ein Beispiel, das sofort funktioniert. Wenn Sie weniger "hacky" wollen, sollten Sie eine Vererbungsbibliothek oder ähnliches verwenden.

Nun, in eine Datei animal.js würden Sie schreiben:

var method = Animal.prototype;

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

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

module.exports = Animal;

So verwenden Sie es in einer anderen Datei:

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

var john = new Animal(3);

Wenn Sie eine "Unterklasse" möchten, dann in 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;

Sie können auch "Methodenausleihe" anstelle der vertikalen Vererbung in Betracht ziehen. Sie müssen nicht von einer "Klasse" erben, um ihre Methode für Ihre Klasse zu verwenden. Zum Beispiel:

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

 }

 method.add = Array.prototype.push;

 ...

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

Da die Node.js-Community sicherstellt, dass neue Funktionen aus der JavaScript ECMA-262-Spezifikation den Entwicklern von Node.js rechtzeitig zur Verfügung gestellt werden.

Sie können sich JavaScript-Klassen ansehen . MDN-Link zu JS-Klassen In der Einführung von JavaScript-Klassen in ECMAScript 6 bietet diese Methode eine einfachere Möglichkeit, OOP-Konzepte in Javascript zu modellieren.

Hinweis : JS-Klassen funktionieren nur im strengen Modus .

Unten finden Sie ein Skelett der Klasse, Vererbung in Node.js (Used Node.js Version v5.0.0 )

Klassenerklärungen:

'use strict'; 
class Animal{

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

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

var a1 = new Animal('Dog');

Vererbung:

'use strict';
class Base{

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

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

var childObj = new Child();

Ich schlage vor, den inheritsmit dem Standardmodul gelieferten Helfer zu verwenden util: http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor

Auf der verlinkten Seite finden Sie ein Beispiel für die Verwendung.

Dies ist das beste Video über objektorientiertes JavaScript im Internet:

Der endgültige Leitfaden für objektorientiertes JavaScript

Beobachten Sie von Anfang bis Ende!

Grundsätzlich ist Javascript eine Prototyp-basierte Sprache, die sich deutlich von den Klassen in Java, C ++, C # und anderen beliebten Freunden unterscheidet. Das Video erklärt die Kernkonzepte weitaus besser als jede Antwort hier.

Mit ES6 (veröffentlicht 2015) haben wir ein Schlüsselwort "class" erhalten, mit dem wir Javascript-Klassen wie mit Java, C ++, C #, Swift usw. verwenden können.

Screenshot aus dem Video, der zeigt, wie eine Javascript-Klasse / Unterklasse geschrieben und instanziiert wird:

In der Javascript-Community argumentieren viele Leute, dass OOP nicht verwendet werden sollte, da das Prototypmodell keine strenge und robuste OOP nativ zulässt. Ich denke jedoch nicht, dass OOP eine Frage der Sprache ist, sondern eher eine Frage der Architektur.

Wenn Sie eine wirklich starke OOP in Javascript / Node verwenden möchten, können Sie sich das Full-Stack-Open-Source-Framework Danf ansehen . Es bietet alle erforderlichen Funktionen für einen starken OOP-Code (Klassen, Schnittstellen, Vererbung, Abhängigkeitsinjektion, ...). Außerdem können Sie auf der Server- (Knoten-) und der Client- (Browser-) Seite dieselben Klassen verwenden. Darüber hinaus können Sie Ihre eigenen Danf-Module codieren und dank Npm mit anderen teilen.

Wenn Sie alleine arbeiten und OOP am nächsten kommen möchten, wie Sie es in Java, C # oder C ++ finden würden, lesen Sie die Javascript-Bibliothek CrxOop. CrxOop bietet eine Syntax, die Java-Entwicklern vertraut ist.

Seien Sie vorsichtig, Javas OOP ist nicht dasselbe wie das in Javascript. Verwenden Sie die CrxOop-Klassen und nicht die CrxOop-Strukturen, um dasselbe Verhalten wie in Java zu erzielen, und stellen Sie sicher, dass alle Ihre Methoden virtuell sind. Ein Beispiel für die Syntax ist:

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

Der Code ist reines Javascript, kein Transpilieren. Das Beispiel stammt aus einer Reihe von Beispielen aus der offiziellen Dokumentation.