如何为JavaScript选择OO设计模式

我所说的OO是指经典的OO。我一直在使用模块模式定义我的“类”（javascript没有传统的类），以提供隐私，并使用对象文本创建“公共静态”集合

当我创建让我决定使用哪种类型的组织的“类”时，我没有指导力量。好的，除了我的代码通过jshint和jslint，并且没有选项集这一事实之外

我正在使用大约1500行代码，所以在代码变得不可管理之前，我需要一种“引导力”，我不得不放弃它

我很清楚用JavaScript编写“类”的不同方法。由Alex MacCaw编写的JavaScript Web应用程序以及这里列出的许多方法所教授的内容

然而，就应用而言，我只是不知道该使用什么方法

最简单的似乎是对象文字中的方法和变量集合，如下所示：

var public_statics = {
    public_func: function () {},
    public_var: "hello"
}

而最复杂的似乎是生活

(function(){
    var private_var;
    function private_func(){
    }
})();

我怎么知道该用哪一种，或者中间有多少变化

举个具体的例子：MVC中的控制器如何

目前（以及一些随机选择的），我实现了如下控制器：

var Co = {};
Co.Controller = function(){
    // 'classes' from Mo are called here
    // 'classes' from Su are called here
}

function __namespace(n, v) {
    return {"meta":{"namespace":n,"version":v}};
}

var FJSL = FJSL == undefined ? new __namespace("Fast JavaScript Library", 0.1) : FJSL;

__using = function(parent, child) {
    clazz = new child();
    clazz.super = new parent();
    if (clazz.super == undefined) return clazz;
    for (a in clazz.super) {
        for (b in clazz) {
            if (a == "constructor" || b == "constructor") continue;
            if (clazz[b] === clazz.super[a]) continue;
            if (a == b && typeof clazz[b] != typeof clazz.super[a]) throw "Typesafety breached on '" + a + "' while trying to resolve polymorphic properties."; 
            if (a == b && typeof clazz[b] == typeof clazz.super[a]) {
                clazz["_"+a] = clazz.super[a];
            } else if (clazz[a] == undefined) {
                clazz[a] = clazz.super[a];
            }
        }
    }
    return clazz;
};

然后我将其他与控制相关的方法附加到Co

如何选择要使用的OO样式

---

已更新

我的库当前分为4个名称空间：

var Mo = {},
    Vi = {},
    Co = {},
    Su = {};

模型、视图和控制器应该是自解释的，并且（支持）支持MVC中未包含的所有“类”，例如DOM访问、效果、调试代码等

我应该使用什么OO风格来进一步组织这个库/代码

控制器“类”示例：

/**
 **  Controller
 */

Co.Controller = function (o_p) {
    var o_p_string_send;
    Su.time();
    o_p = Mo[o_p.model].pre(o_p);
    if (o_p.result !== 'complete') {
        o_p_string_send = JSON.stringify(o_p);
        Su.time();
        //Su.log(o_p_string_send);
        Co.serverCall('pipe=' + o_p_string_send, function (o_p_string_receive) {
            Su.time();
            //Su.log(o_p_string_receive);
            o_p.server = JSON.parse(o_p_string_receive);
            Mo[o_p.model].post(o_p);
            Su.time(true);
            Su.log('Server time: [' + o_p.server.time + ']');
        });
    }
};

---

我个人更喜欢这种生活，因为你可以将方法私有化。否则，您将不得不使用下划线进行某种奇怪的约定

---

此外，从风格上讲，如果将其封装在函数中，则可以选择使用分号，这是一种简单的旧javascript。要求object literal中的每一行以逗号结尾对我来说似乎很有趣。

IFFE

s经常让人读起来很困惑，就我个人而言，我不知道它们为什么会变得如此主流。我认为代码应该易于阅读和简洁。试图模拟不属于语言规范的语言行为往往是一个非常愚蠢的想法

例如，JavaScript不支持多重继承、多态性或许多其他有趣的范例。所以很多时候，我们看到人们试图在JS中创建一些疯狂的方式，比如说有多态性或者私有成员等等。我认为这是一个错误

我目前正在一个高性能JS数据结构库上做一个业余项目（我试图超越Google的Close和其他一些）。来自C++和java背景，我总是喜欢制作类，我喜欢继承等等，让我和大家分享一些代码片段。起初，我认为我很聪明，因为我写了这样的东西：

var Co = {};
Co.Controller = function(){
    // 'classes' from Mo are called here
    // 'classes' from Su are called here
}

function __namespace(n, v) {
    return {"meta":{"namespace":n,"version":v}};
}

var FJSL = FJSL == undefined ? new __namespace("Fast JavaScript Library", 0.1) : FJSL;

__using = function(parent, child) {
    clazz = new child();
    clazz.super = new parent();
    if (clazz.super == undefined) return clazz;
    for (a in clazz.super) {
        for (b in clazz) {
            if (a == "constructor" || b == "constructor") continue;
            if (clazz[b] === clazz.super[a]) continue;
            if (a == b && typeof clazz[b] != typeof clazz.super[a]) throw "Typesafety breached on '" + a + "' while trying to resolve polymorphic properties."; 
            if (a == b && typeof clazz[b] == typeof clazz.super[a]) {
                clazz["_"+a] = clazz.super[a];
            } else if (clazz[a] == undefined) {
                clazz[a] = clazz.super[a];
            }
        }
    }
    return clazz;
};

我是这样使用它的（在一个简单队列的示例中）：

---

它易于理解、修改和扩展。如果您的系统很脆弱，如果有人意外更改了某个“私有”变量，那么您只需对其进行记录。

因为JavaScript语言本身是以许多不同的方式实现的，即每个浏览器的实现方式不同，所以您必须从不一致性开始

JavaScript不直接支持经典继承。（它支持原型继承）

出于我的需要，我将选择不实现经典继承。这不是理想的BC。经典继承允许您直接实现最佳实践OO封装、继承和多态性

然而，我更愿意等到该语言通过经典继承或类似方式直接支持OO

---

同时，我将只使用基本的原型继承来帮助实现代码重用。

没有接近您的SO分数，这让我担心我的观点是无知的，但OO设计用于代码重用不是主要论点吗？对于单次使用但复杂的应用程序，可能会有一些可维护性提示？在JavaScript中，您可以选择，因此答案可能更复杂。。。好问题，我面临着同样的困境，最困难的部分是让JS成为JS，而不是试图打败它，使其表现得像Java（或类似的东西）。我尝试使用名称空间和“保持简单”，这一切都取决于您试图实现的目标。您使用类是为了从继承中获益吗？本例中的控制器不使用继承。问题已经更新以反映这一点。您是否在代码中使用过“new”关键字，或者所有对象都是像您的示例中那样从普通对象生成的？超过1500行时，我可以选择对所有“类”使用iLife吗？我是否需要担心增加处理以立即执行？我相信是这样。另外，作为个人选择，我在单独的文件中编写类，就像在Java中一样。我使用node.js的grunt之类的工具将文件连接/缩小到一起进行分发。作为一个略微相切的地方，您可能希望看看require.js，它除了使模块与浏览器和节点兼容之外，还封装了模块。它可能会使您更接近熟悉的Java开发环境（如果这是您的目标的话）。对于介于两者之间的环境，例如构造函数函数……

var constructor\u function=function（）{//private stuff}

,，这为隐私和实例提供了一种自然语言结构，通过

新的构造函数\函数
？@hiroprotation:我认为这是一种非常合适的方法。构造函数是语言的一部分，尽管它们可能更难理解
var public_statics = {
    public_func: function () {},
    public_var: "hello"
}