web-dev-qa-db-ja.com

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() {}
    }
}

vs.

this.Class = function() {}

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

...

継承はどのように機能しますか？

NodeJSにOOPを実装するための特定のモジュールはありますか？

OOPに似たものを作成するための1000の異なる方法を見つけています。

ボーナス質問：MongooseJSで使用するために推奨される「OOPスタイル」は何ですか？ （MongooseJSドキュメントをクラスと見なし、モデルをインスタンスとして使用できますか？）

編集

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)
javascriptnode.jsoopinheritancemongoose
101
fusio

これは、すぐに使用できる例です。 「ハッキング」を減らしたい場合は、継承ライブラリなどを使用する必要があります。

さて、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;
110
Esailija

Node.jsコミュニティは、JavaScript ECMA-262仕様の新機能がNode.js開発者にタイムリーに提供されるようにします。

JavaScriptクラスをご覧ください。 JSクラスへのMDNリンク ECMAScript 6 JavaScriptクラスで導入されたこのメソッドは、JavascriptでOOP概念をモデル化する簡単な方法を提供します。

注：JSクラスはstrictモードでのみ動作します。

以下に、Node.jsで記述された継承クラスの一部のスケルトンを示します（Node.jsバージョン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();
41
Piyush Sagar

標準のinheritsモジュールに付属するutilヘルパーを使用することをお勧めします： http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor

リンクされたページでそれを使用する方法の例があります。

14
badsyntax

これは、インターネット上のオブジェクト指向JavaScriptに関する最高のビデオです。

オブジェクト指向JavaScript決定版ガイド

最初から最後まで見てください!!

基本的に、Javascriptは プロトタイプベース 言語であり、Java、C++、C＃、およびその他の一般的な友人のクラスとはまったく異なります。ビデオは、ここでの答えよりもはるかにコアの概念を説明しています。

ES6（2015年リリース）では、「class」キーワードを取得しました。これにより、Java、C++、C＃、SwiftなどでJavascriptの「クラス」を使用できます。

Javascriptクラス/サブクラスを作成およびインスタンス化する方法を示すビデオのスクリーンショット： enter image description here

9
etayluz

Javascriptコミュニティでは、プロトタイプモデルでは厳密で堅牢なOOP_をネイティブに実行できないため、多くの人がOOPを使用すべきではないと主張しています。ただし、OOPは言語の問題ではなく、アーキテクチャの問題だとは思いません。

Javascript/Nodeで強力なOOPを使用する場合は、フルスタックのオープンソースフレームワーク Danf をご覧ください。強力なOOPコードに必要なすべての機能（クラス、インターフェース、継承、依存関係注入など）を提供します。また、サーバー（ノード）側とクライアント（ブラウザー）側の両方で同じクラスを使用できます。さらに、独自のdanfモジュールをコーディングして、Npmのおかげで誰とでも共有できます。

4
Gnucki