JavaScript: The Good Parts - 如何完全不使用`new`

Question

Crockford 的书 JavaScript: The Good Parts 说（第 114 页）构造函数应该总是以首字母大写（即 Point）命名，并且具有首字母大写字母的函数名称应仅与构造函数一起使用（其他所有内容都应为小写）。

此约定有助于我们避免忘记将new 运算符与构造函数一起使用。

他接着说“[a]n 更好的应对策略是根本不使用new。”

我的问题是，我们如何在不使用 new 的情况下编写 JavaScript？

• 我们可以使用文字{} 和[] 来避免new Object() 和new Array()。
• 我们可以避免new Number()、new Boolean()和new String()与0、true和''。
• 我们可以用/pattern/ 之类的东西来避免new RegExp()。

我们如何避免new Date()？

而且，最重要的是，我们如何避免将new 与我们自己的自定义对象一起使用？

Answer 1

Crockford 提供了一个对象创建函数的示例，JS 本身应该在他的 Javascript 演讲中提供了一个示例，该演讲可在 http://developer.yahoo.com/yui/theater/ 上获得

然而，YUI(3) 团队本身使用“new”，并且他们确实遵循了他的建议（因为他是 Yahoo 首席 JS 架构师（更新：他继续前进，但在最初撰写此回复时声明是正确的） .我理解这个特定的陈述更多的是在“学术”层面上,应该是什么语言被设计成“正确的”而不是一些基于类的继承东西的残余物。他(恕我直言)说的那样事实证明 JS 是有冲突的，基于原型的，但有一个来自“经典类”继承语言的东西。

不过，JS 就是这样，去用“new”吧。

你可以在这里找到他的对象创建函数：http://javascript.crockford.com/prototypal.html

 if (typeof Object.create !== 'function') {
     Object.create = function (o) {
         function F() {}
         F.prototype = o;
         return new F();
     };
 }
 newObject = Object.create(oldObject);

编辑：更新为使用 Crockford 的该功能的最新版本 - 共有三个。

更新 2015 年 6 月：我们使用 Object.create(...) 已经有一段时间了，所有当前浏览器都支持（包括 IE 9 及更高版本），因此无需使用 Crockford 的功能。

然而，事实证明，如果你使用Object.create，你应该确保你不要经常这样做：该功能比使用new Constructor()慢得多！

请参阅http://mrale.ph/blog/2014/07/30/constructor-vs-objectcreate.html 了解解释（V8 引擎），请参阅http://jsperf.com/object-create-vs-crockford-vs-jorge-vs-constructor/62 了解性能演示。

另一个不拒绝 new Constructor(...) 的原因是 ES6 classes 肯定会得到广泛采用，即使只是因为大多数 Javascript 开发人员来自基于类的语言这一简单原因。

还可以查看这篇文章，它主张 Object.create: http://davidwalsh.name/javascript-objects-deconstruction

不管你喜不喜欢，尤其是在你想与广泛的人分享的项目中（在空间和时间上——意思是正确的，也不是随着时间的推移，其他人接替你）有更多使用 @987654334 的理由@。

更新 2015 年 9 月：对于我自己，我已经开始使用 ES 2015 Javascript 来处理所有事情 - 使用 io.js 和/或 Babel。除了像 new Error(...) 这样的 Javascript 内置插件外，我也不会在我的项目中使用 any new。我更喜欢使用功能更强大的方法，我完全忽略了对象系统。 [my-object].prototype 和 this 完全从我的项目中消失了。很长一段时间以来，我都对这些想法持怀疑态度，“因为对象工作得很好”。但是在一个新的（io.js）项目开始时非常不情愿地尝试它之后，它“点击”了，我不明白为什么我浪费了二十年。好吧，不完全是，今天的 JS 引擎和硬件更有利于这种风格。特别是在 ES 2015 中，我建议提供一个完全没有任何 this 和 class（新的 ES 2015 关键字或整个概念，基于使用 constructorFn.prototype）的函数式样式。这可能需要你几个星期，但一旦它“点击”我保证你永远不会回去 - 不是自愿的。它更方便、更强大。

更新 2018 年 2 月：虽然我仍然在做我在上一次更新中写的内容，但我现在想补充一点，有时课程很好。没有绝对的。 :-)

Answer 2

你被困在使用“新”来实例化其他人的对象。但是对于您自己的代码，您可以避免“this”和“new”的陷阱。

（顺便说一下，问题不在于 'new' 本身。但是用 'new' 实例化的对象可能在内部使用 'this'。使用 'this' 会导致频繁和微妙的错误，因为javascript 的 'this' 要求 调用者 做额外的工作来将被调用的方法绑定到正确的对象，并且在运行前很难 lint 或以其他方式检测到不正确的绑定。）

短版：

为避免使用“new”来实例化您编写的对象，只需从任何函数返回一个对象。在该函数内部，将任何方法附加到该对象并进行任何初始化。你完成了——这个函数既是你的类定义又是构造函数。

长版，例如：

以下“self”模式避免同时使用“new”和“this”。虽然该模式确实在每个对象中存储方法副本，但这并不重要，除非您在运行时创建大量对象。如果是这种情况，那么您始终可以使用http://justjs.com/posts/this-considered-harmful 中的“flyweight”模式。 （虽然该页面上的示例仍然使用了一点“this”，但也需要稍作调整以使其适应以下模式。）

// this function defines a "class" -- the whole function is the constructor
function Foo(x) {
    // create/init whatever object type you want here
    var self = {x: x};
    // if subclassing, for instance, you can do:
    // var self = Baz(x);

    // public method
    self.foo = function() {
        return self.x;
    };

    // public method
    self.bar = function() {
        console.log(self.x);
        logger();
    };

    // private method
    function logger() {
        console.log(self.x);
    }

    // ...more constructor bits can go here

    // don't forget to return self
    return self;
}

var f = Foo(1); 
var g = Foo(2); 
setTimeout(f.bar, 1000);
setTimeout(g.bar, 1000);

console.log(g.foo()); // 2
g.x = 5;
console.log(f.foo()); // 1
console.log(g.foo()); // 5

// ...then, 1 second later:
// 1  (from f.bar)
// 1  (from f.logger)
// 5  (from g.bar)
// 5  (from g.logger)

// blows up if uncommented
// f.logger();

Answer 3

不使用 new 并盲目关注 Crockford 是愚蠢的。

了解 JavaScript 并编写好的代码。使用 new 关键字是 JavaScript OO 的基石。

避免new，你会错过很多好的 JavaScript 代码。

与其随意地从你的工具包中删减大量内容，不如学习并正确使用它。

Crockford 习惯说 JavaScript 中任何给他的代码带来错误的东西都是不好的。

我个人会继续说“[a]更好的应对策略是胜任。”

Answer 4

我也不知道如何避免new Date() 或new XMLHttpRequest()。但我确实知道如何避免将 new 用于我自己的类型。

首先，我从Object.create() 开始。这是一种 ES5 方法，因此并非在任何地方都可用。我使用es5-shim 添加它，然后我就可以开始了。

我喜欢模块模式，所以我首先将我的类型包装在一个自动执行的匿名函数 var Xyz = (function() {...})() 中。这意味着我有一个私人空间可以工作，而不会在全局命名空间中弄得一团糟。我返回一个带有create() 函数和prototype 属性的对象。 create() 功能适用于我这种类型的用户。当他们想要一个时，他们调用Xyz.create()，并取回一个新的、已初始化的我类型的对象。如果人们想要继承，prototype 属性可用。

这是一个例子：

var Vehicle = (function(){
        var exports = {};
        exports.prototype = {};
        exports.prototype.init = function() {
                this.mph = 5;
        };
        exports.prototype.go = function() {
                console.log("Going " + this.mph.toString() + " mph.");
        };

        exports.create = function() {
                var ret = Object.create(exports.prototype);
                ret.init();
                return ret;
        };

        return exports;
})();

继承看起来像这样：

var Car = (function () {
        var exports = {};
        exports.prototype = Object.create(Vehicle.prototype);
        exports.prototype.init = function() {
                Vehicle.prototype.init.apply(this, arguments);
                this.wheels = 4;
        };

        exports.create = function() {
                var ret = Object.create(exports.prototype);
                ret.init();
                return ret;
        };

        return exports; 

})();

Answer 5

您可以通过返回匿名对象并在构造函数中使用闭包来避免“新建”。这也有助于您隐藏私人数据。

考虑：

function SomeCounter(start) {

    var counter = start;

    return {
        getCounter : function() {
            return counter;
        },

        increaseCounter : function() {
            counter++;
        }

    };
}

现在要使用它，你需要做的就是

var myCounter = SomeCounter(5);
myCounter.increaseCounter();
console.log(myCounter.getCounter()); //should log 6

这样做的好处是您不需要记住使用“新”，但如果您这样做不会伤害您。

var myCounter = new SomeCounter(5); //still works

Answer 6

这个问题已经被问及回答了：Is JavaScript's "new" keyword considered harmful?

正如 Raynos 所说，盲目追随 Crockford（或其他任何人）而不理解为什么他们会说他们所做的事情，这是愚蠢的。

Answer 7

您可以通过创建工厂函数来避免new：

var today = Date.getToday();

（如果您想知道，您无法在工厂函数本身上避免它：）

Date.getToday = function() { return new Date(); };

虽然我认为你应该创建这样的函数，如果它增加了语义值（如上面的例子）或者你可以默认一些构造函数参数。换句话说，不要只是为了避免使用new。

Answer 8

function F() { return { /* your fields and methods here */ } }

Answer 9

我认为他关于不使用 new 的建议是概念性的（学术性的），不能从字面上理解。 Date 类是该规则的一个完美例外，因为您如何使用标准 ECMAScript 获取当前（或任意）日期对象？

但是，关于不将new 与您自己的自定义对象一起使用，您可以使用一些策略。一种是使用类似工厂的方法而不是构造函数，构造函数可以将对象实例作为参数来“祝福”您的新类型，或者默认使用新的对象字面量。考虑以下几点：

var newCar = function(o) {
  o = o || {};
  // Add methods and properties to "o"...
  return o;
}