노드의 JavaScript OOPJS: 어떻게?

노드의 JavaScript OOPJS: 어떻게?

저는 자바에서처럼 고전적인 OOP에 익숙합니다.

NodeJS를 사용하여 자바스크립트에서 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)

이것은 즉시 사용할 수 있는 예입니다.덜 "해키"를 원한다면 상속 라이브러리 등을 사용해야 합니다.

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

"하위 클래스"를 원한다면 마우스 안에 있습니다.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 개발자에게 적시에 제공되도록 보장합니다.

자바스크립트 클래스를 볼 수 있습니다.JS 클래스에 대한 MDN 링크 ECMA스크립트 6 JavaScript 클래스에 도입된 이 방법은 Javascript에서 OOP 개념을 모델링하는 더 쉬운 방법을 제공합니다.

참고: 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();

는 사할것제다니합안을용을 하는 것을 합니다.inherits 표과 준미는도우되공제와 함께 util모듈: http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor

링크된 페이지에 사용 방법에 대한 예시가 있습니다.

이것은 인터넷에서 객체 지향 자바스크립트에 관한 최고의 비디오입니다.

객체 지향 자바스크립트의 결정적 가이드

처음부터 끝까지 보세요!!

기본적으로 Javascript는 Java, C++, C# 및 기타 인기 있는 친구들의 클래스와는 상당히 다른 프로토타입 기반 언어입니다.이 비디오는 여기서 어떤 대답보다 핵심 개념을 훨씬 더 잘 설명합니다.

ES6(2015년 출시)에서는 Java, C++, C#, Swift 등과 같이 Javascript "class"를 사용할 수 있는 "class" 키워드가 제공되었습니다.

Javascript 클래스/하위 클래스를 작성하고 인스턴스화하는 방법을 보여주는 비디오의 스크린샷:

자바스크립트 커뮤니티에서는 프로토타입 모델이 엄격하고 강력한 OOP를 네이티브로 수행할 수 없기 때문에 OOP를 사용해서는 안 된다고 주장하는 사람들이 많습니다.하지만 저는 OOP가 언어의 문제가 아니라 건축의 문제라고 생각합니다.

Javascript/Node에서 정말 강력한 OOP를 사용하고 싶다면 풀 스택 오픈 소스 프레임워크 Danf를 볼 수 있습니다.강력한 OOP 코드(클래스, 인터페이스, 상속, 종속성 주입 등)에 필요한 모든 기능을 제공합니다.또한 서버(노드)와 클라이언트(브라우저) 양쪽에서 동일한 클래스를 사용할 수 있습니다.게다가, 당신은 Npm 덕분에 당신 자신의 danf 모듈을 코딩하고 누구와도 공유할 수 있습니다.

Java, C# 또는 C++에서 찾을 수 있는 것처럼 OOP에 가장 가까운 것을 원한다면 Javascript 라이브러리인 CrxOop을 참조하십시오.CrxOop은 Java 개발자에게 다소 익숙한 구문을 제공합니다.

자바의 OOP는 자바스크립트에서 발견되는 것과 같지 않습니다.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);

코드는 순수 자바스크립트이며, 트랜스파일링은 없습니다.이 예제는 공식 문서의 여러 예제에서 가져온 것입니다.

언급URL : https://stackoverflow.com/questions/18188083/javascript-oop-in-nodejs-how