将javascript函数重写为node.js模块

我有这个函数：（我猜这是用于创建javascript对象的抽象工厂）

A使用它定义类C/java语法，如多态性和扩展：

var Bullet = $class({

    Extends: GameObject,

    constructor: function(texturePath, x, y, ctx, direction, passable, player) {
        GameObject.call(this, texturePath, x, y, ctx, 1, 1, passable, new Array(8, 8, 0, 0));
    },

    isActive: function() {
    },

    getPlayer: function() {
    },

    update: function(dt) {
    },

    destroy: function() {
    },

    processCollision: function() {
    }
});

然后打电话：

var bullet = new Bullet(params);

我尝试将其重写为nodejs模块，如下所示：

(function(){
var $class = function(definition) {
    var constructor = definition.constructor; 
    var parent = definition.Extends;
    if (parent) {
        var F = function() { };
        constructor._superClass = F.prototype = parent.prototype;
        constructor.prototype = new F();
    }
    for (var key in definition) {
        constructor.prototype[key] = definition[key];
    }
    constructor.prototype.constructor = constructor;
    return constructor;
};
module.exports.createClass = function() {
    return $class();
}
});

var func = function(definition) {
    var constructor = definition.constructor; 
    var parent = definition.Extends;
    if (parent) {
        var F = function() { };
        constructor._superClass = F.prototype = parent.prototype;
        constructor.prototype = new F();
    }
    for (var key in definition) {
        constructor.prototype[key] = definition[key];
    }
    constructor.prototype.constructor = constructor;
    return constructor;
};

module.exports.createClass = func;

然后用以下词语来称呼它：

var c = require(__dirname + "\\Class");
var Bullet = c.createClass({
   Extends: GameObject,
    constructor: function() {}
});

但是不行，你能帮我重写一下吗

更新：我从@Salem answer重写了它，但在这个过程中我丢失了扩展和多态性。 为了得到扩展，我只需要写作，而不是写作

Extends: ParentClass

这：

我预计多态性会是这样的：

// in class which is extended from ParentClass
ParentClass.method();

// in parent class adding line
module.exports.method = ParentClass.method;

但这是未定义的。那么陷阱在哪里呢

---

最后我在nodejs中使用了mochiscript模块，它具有更好的语法和更多面向对象的功能。

在您的代码中，

createClass

是一个没有任何参数的函数。您也可以调用

$class

，而不使用任何参数

您不需要将所有代码包装在一个函数中，因为您在其中声明的所有内容都无法从外部访问，除非您导出它。所以应该是这样的：

(function(){
var $class = function(definition) {
    var constructor = definition.constructor; 
    var parent = definition.Extends;
    if (parent) {
        var F = function() { };
        constructor._superClass = F.prototype = parent.prototype;
        constructor.prototype = new F();
    }
    for (var key in definition) {
        constructor.prototype[key] = definition[key];
    }
    constructor.prototype.constructor = constructor;
    return constructor;
};
module.exports.createClass = function() {
    return $class();
}
});

var func = function(definition) {
    var constructor = definition.constructor; 
    var parent = definition.Extends;
    if (parent) {
        var F = function() { };
        constructor._superClass = F.prototype = parent.prototype;
        constructor.prototype = new F();
    }
    for (var key in definition) {
        constructor.prototype[key] = definition[key];
    }
    constructor.prototype.constructor = constructor;
    return constructor;
};

module.exports.createClass = func;

---

这意味着，如果您需要此模块作为

X

，那么您唯一可以访问的是

X.createClass

，而不是

X.func

或任何其他内容。

如果我想从func访问方法，该怎么办？我想调用它以获得多态性。您仍然可以访问

func

，但可以使用名称

createClass

（

X.createClass（something）.someMethod（）

）。我的意思是，只有导出的引用在外部可见。如果定义了另一个名为

func2

的函数，除非明确导出它，否则无法从外部访问它。因此，这里不需要将所有代码包装到函数中。