我一直在重构别人的 JavaScript 代码。

BEFORE:

function SomeObj(flag) {
    var _private = true;
    this.flag = (flag) ? true : false;
    this.version="1.1 (prototype)";
    if (!this._someProperty) this._init();
            // leading underscore hints at what should be a 'private' to me
    this.reset(); // assumes reset has been added...
}

SomeObj.prototype.reset = function() {
    /* perform some actions */
}

/* UPDATE */
SomeObj.prototype.getPrivate = function() {
    return _private; // will return undefined
}

/* ...several other functions appended via `prototype`...*/

AFTER:

var SomeObj = function (flag) {
    var _private = true;
    this.flag = (flag) ? true : false;
    this.version = "2.0 (constructor)";

    this.reset = function () {
       /* perform some actions */
    };

    /* UPDATE */
    this.getPrivate = function() {
        return _private; // will return true
    }

    /* other functions and function calls here */
}

对我来说，第一个示例看起来很难阅读，尤其是在更大的上下文中。添加方法如reset像这样，使用prototype属性，似乎不太受控制，因为它可能发生在脚本中的任何地方。我的重构代码（上面的第二个示例）对我来说看起来更加整洁，因此更易于阅读，因为它是独立的。我通过变量声明获得了一些隐私，但失去了原型链的可能性。

...

问题：

1. 首先，我有兴趣知道我还因上述内容而失去了什么prototype，或者原型链的丢失是否会产生更大的影响。本文已经 6 岁了，但声称使用prototype在大规模上，属性比封闭模式更有效。

2. 上面的两个例子仍然会被实例化new操作员;他们都是“经典”的构造函数。最终我什至想从这个模型转移到一个模型，其中所有属性和函数都声明为var我有一个公开的方法，它能够返回一个对象，打开我需要的所有属性和方法，对私有者拥有特权（通过封闭）。像这样的东西：

   var SomeObj = (function () {
   
       /* all the stuff mentioned above, declared as 'private' `var`s */
   
       /* UPDATE */
       var getPrivate = function () {
           return private;
       }
   
       var expose = function (flag) {
            // just returns `flag` for now
            // but could expose other properties
            return {
                flag: flag || false, // flag from argument, or default value
                getPrivate: getPrivate
            } 
       };
   
       return {
           expose: expose
       }
   })(); // IIFE
   
   // instead of having to write `var whatever = new SomeObj(true);` use...
   var whatever = SomeObj.expose();
   

   StackOverflow 上有一些关于“原型与闭包”问题的答案（here and here， 例如）。但是，正如prototype财产，我感兴趣的是朝着这个方向以及远离new运算符意味着我的代码的效率和任何可能性的损失（例如instanceof丢失了）。如果我无论如何都不打算使用原型继承，那么我实际上会失去任何东西吗？new操作员？

3. 鉴于我要求提供上述细节，如果允许的话，这是一个更宽松的问题：如果prototype and new确实是最有效的方法，比闭包具有更多优势（无论您认为它们可能是什么），是否有任何指南或设计模式可以以更简洁的方式编写它们？

...

UPDATE:

注意expose每次都会返回一个新对象，因此这就是实例化发生的地方。据我了解，该对象指的是在SomeObj闭包，它们在所有对象中都是相同的方法（除非被覆盖）。在这种情况下flag变量（我现在已经更正了），这可以从参数继承expose，有一个默认值，或者再次引用封装的预先存在的方法或属性。因此，存在正在生成的对象的实例，并且这里发生了一些继承（加上多态性？）。

因此，重复问题 2：如果我无论如何都不打算使用原型继承，那么我实际上会失去前面提到的任何东西吗？new操作员？

非常感谢到目前为止的回答，这有助于澄清我的问题。

根据我的经验，不使用你唯一失去的东西.prototype是内存 - 每个对象最终都拥有自己的其中定义的函数对象的副本。

如果您只想实例化“少量”对象，这可能不是一个大问题。

关于您的具体问题：

1. 该链接文章的第二条评论非常相关。作者的基准是错误的 - 它正在测试运行构造函数的开销also声明四个内部函数。它是not测试这些功能的后续性能。

2. 您的“关闭和公开”代码示例不是面向对象的，它只是带有一些封闭的私有变量的名称空间。由于它不使用new如果您希望从中实例化对象，那么它是没有用的。

3. 我无法回答这个问题——“视情况而定”是你能得到的最好的答案。