JavaScript OOP ใน NodeJS: อย่างไร

ฉันคุ้นเคยกับ OOP แบบคลาสสิกเช่นเดียวกับใน Java

แนวทางปฏิบัติที่ดีที่สุดในการทำ OOP ใน JavaScript โดยใช้ NodeJS คืออะไร?

แต่ละ Class เป็นไฟล์ที่มีmodule.export?

จะสร้างชั้นเรียนได้อย่างไร?

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

เทียบกับ (ฉันไม่แน่ใจว่าถูกต้องด้วยซ้ำ)

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

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

เมื่อเทียบกับ

this.Class = function() {}

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

...

มรดกจะทำงานอย่างไร?

มีโมดูลเฉพาะสำหรับการนำ OOP ไปใช้ใน NodeJS หรือไม่

ฉันกำลังหาวิธีที่แตกต่างกันกว่าพันวิธีในการสร้างสิ่งต่างๆที่มีลักษณะคล้าย OOP .. แต่ฉันไม่รู้ว่าวิธีใดที่ใช้งานได้จริง / สะอาดที่สุด

คำถามโบนัส : "สไตล์ OOP" ที่แนะนำสำหรับใช้กับ MongooseJS คืออะไร? (เอกสาร MongooseJS สามารถมองเห็นเป็น Class และแบบจำลองที่ใช้เป็นอินสแตนซ์ได้หรือไม่)

แก้ไข

นี่คือตัวอย่างใน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)

นี่คือตัวอย่างที่ใช้งานได้นอกกรอบ หากคุณต้องการความ "แฮ็ก" น้อยลงคุณควรใช้ไลบรารีการสืบทอดหรืออื่น ๆ

ในไฟล์ 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;

ในฐานะที่เป็นชุมชน Node.js ทำให้มั่นใจได้ว่าคุณลักษณะใหม่ ๆ จากข้อกำหนดของ JavaScript ECMA-262 จะถูกนำมาสู่นักพัฒนา Node.js ในเวลาที่เหมาะสม

คุณสามารถดูที่เรียน JavaScript ลิงก์ MDN ไปยังคลาส JS ในคลาส JavaScript ECMAScript 6 ถูกนำมาใช้วิธีนี้ให้วิธีที่ง่ายกว่าในการสร้างโมเดลแนวคิด OOP ใน Javascript

หมายเหตุ : การเรียน JS จะทำงานเฉพาะในโหมดที่เข้มงวด

ด้านล่างนี้เป็นโครงกระดูกของคลาสมรดกที่เขียนใน 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();

ฉันขอแนะนำให้ใช้ตัวinheritsช่วยที่มาพร้อมกับutilโมดูลมาตรฐาน: http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor

มีตัวอย่างวิธีการใช้งานในหน้าที่เชื่อมโยง

นี่คือวิดีโอที่ดีที่สุดเกี่ยวกับ Object-Oriented JavaScript บนอินเทอร์เน็ต:

คำแนะนำขั้นสุดท้ายสำหรับ JavaScript เชิงวัตถุ

ดูตั้งแต่ต้นจนจบ !!

โดยทั่วไป Javascript เป็นภาษาต้นแบบซึ่งค่อนข้างแตกต่างจากคลาสใน Java, C ++, C # และเพื่อนที่เป็นที่นิยมอื่น ๆ วิดีโออธิบายแนวคิดหลักได้ดีกว่าคำตอบใด ๆ ที่นี่

ด้วย ES6 (เปิดตัวในปี 2015) เรามีคีย์เวิร์ด "class" ซึ่งทำให้เราสามารถใช้ "คลาส" ของ Javascript ได้เหมือนกับที่เราทำกับ Java, C ++, C #, Swift และอื่น ๆ

ภาพหน้าจอจากวิดีโอแสดงวิธีการเขียนและสร้างอินสแตนซ์คลาส Javascript / คลาสย่อย:

ในชุมชน Javascript ผู้คนจำนวนมากโต้แย้งว่าไม่ควรใช้ OOP เนื่องจากโมเดลต้นแบบไม่อนุญาตให้ทำ OOP ที่เข้มงวดและมีประสิทธิภาพ อย่างไรก็ตามฉันไม่คิดว่า OOP เป็นเรื่องของภาษา แต่เป็นเรื่องของสถาปัตยกรรมมากกว่า

หากคุณต้องการใช้ OOP จริงที่แข็งแกร่งใน Javascript / โหนดคุณสามารถดูได้ที่เต็มรูปแบบสแต็คมาเปิดกรอบDanf มีคุณสมบัติที่จำเป็นทั้งหมดสำหรับรหัส OOP ที่แข็งแกร่ง (คลาส, อินเทอร์เฟซ, การสืบทอด, การพึ่งพาการฉีด, ... นอกจากนี้ยังอนุญาตให้คุณใช้คลาสเดียวกันทั้งบนฝั่งเซิร์ฟเวอร์ (โหนด) และไคลเอนต์ (เบราว์เซอร์) ยิ่งไปกว่านั้นคุณสามารถโค้ดโมดูล danf ของคุณเองและแชร์กับใครก็ได้ด้วย Npm

หากคุณกำลังทำงานด้วยตัวเองและต้องการสิ่งที่ใกล้เคียงที่สุดกับ OOP อย่างที่คุณพบใน Java หรือ C # หรือ C ++ โปรดดูไลบรารี javascript CrxOop CrxOop ให้ไวยากรณ์ที่คุ้นเคยกับนักพัฒนา Java

โปรดระวัง OOP ของ Java ไม่เหมือนกับที่พบใน Javascript เพื่อให้ได้พฤติกรรมเช่นเดียวกับใน Java ให้ใช้คลาสของ CrxOop ไม่ใช่โครงสร้างของ CrxOop และตรวจสอบให้แน่ใจว่าวิธีการทั้งหมดของคุณเป็นเสมือนจริง ตัวอย่างของไวยากรณ์คือ

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

รหัสเป็นจาวาสคริปต์ล้วนๆไม่มีการถ่ายทอด ตัวอย่างนี้นำมาจากตัวอย่างจำนวนหนึ่งจากเอกสารอย่างเป็นทางการ