JavaScript 的“new”关键字被认为是有害的吗？

Crockford 在推广优秀的 JavaScript 技术方面做了很多工作。他对语言关键要素的固执己见引发了许多有益的讨论。也就是说，有太多的人把每一个“坏”或“有害”的宣言都当作福音，拒绝超越一个人的看法。有时可能会有点令人沮丧。

与从头开始构建每个对象相比，使用 new 关键字提供的功能有几个优点：

原型继承。尽管那些习惯于基于类的 OO 语言的人经常带着怀疑和嘲笑的态度看待，但 JavaScript 的本机继承技术是一种简单且令人惊讶的代码重用方法。 new 关键字是使用它的规范（也是唯一可用的跨平台）方法。表现。这是 #1 的副作用：如果我想为我创建的每个对象添加 10 个方法，我可以编写一个创建函数，手动将每个方法分配给每个新对象……或者，我可以将它们分配给创建函数的原型，并使用 new 来剔除新对象。这不仅更快（原型上的每个方法都不需要代码），而且避免了为每个方法使用单独的属性来膨胀每个对象。在速度较慢的机器（尤其是速度较慢的 JS 解释器）上，当创建许多对象时，这可能意味着显着节省时间和内存。

是的，new 有一个关键的缺点，其他答案巧妙地描述了：如果您忘记使用它，您的代码将在没有警告的情况下中断。幸运的是，这个缺点很容易得到缓解——只需在函数本身中添加一些代码：

function foo()
{
   // if user accidentally omits the new keyword, this will 
   // silently correct the problem...
   if ( !(this instanceof foo) )
      return new foo();
   
   // constructor logic follows...
}

现在您可以享受 new 的优势，而不必担心意外误用导致的问题。

John Resig 在他的 Simple "Class" Instantiation 帖子中详细介绍了这种技术，并在默认情况下将这种行为构建到您的“类”中。绝对值得一读...正如他即将出版的书 Secrets of the JavaScript Ninja，它在 JavaScript 语言的这个和许多其他“有害”特性中发现了隐藏的黄金（with 中的章节尤其对于我们这些最初将这个备受诟病的功能视为噱头的人来说很有启发性）。

通用的健全性检查

您甚至可以在检查中添加一个断言，如果您对损坏的代码无声工作的想法感到困扰。或者，正如 some 所评论的，使用检查来引入运行时异常：

if ( !(this instanceof arguments.callee) ) 
   throw new Error("Constructor called as a function");

请注意，此代码段能够避免对构造函数名称进行硬编码，因为与前面的示例不同，它不需要实际实例化对象 - 因此，可以将其复制到每个目标函数中而无需修改。

ES5 带走

正如 Sean McMillan、stephenbez 和 jrh 所指出的，arguments.callee 的使用在 ES5 的 strict mode 中是无效的。因此，如果您在该上下文中使用上述模式，它将引发错误。

ES6 和一个完全无害的新

ES6 将 Classes 引入 JavaScript - 不，不是以老式 Crockford 所做的怪异的 Java 风格，而是在精神上更像他（和其他人）后来采用的轻量级方式，采用了 prototypal 的最佳部分继承和烘焙通用模式到语言本身。

...其中一部分包括一个安全的 new：

class foo
{
  constructor()
  {
    // constructor logic that will ONLY be hit 
    // if properly constructed via new
  } 
}

// bad invocation
foo(); // throws, 
// Uncaught TypeError: class constructors must be invoked with 'new'

但是，如果您不想使用新糖怎么办？如果您只想使用上面显示的那种安全检查来更新您完美的旧式原型代码，以便它们继续在严格模式下工作怎么办？

好吧，就像 Nick Parsons notes 一样，ES6 也以 new.target 的形式提供了一个方便的检查：

function foo()
{
  if ( !(new.target) ) 
     throw new Error("Constructor called as a function");
   
  // constructor logic follows...
}

因此，无论您选择哪种方法，只要稍加考虑并保持良好的卫生习惯，您都可以使用 new 而不会造成伤害。

---

我刚刚阅读了他的 Crockfords 书“Javascript: The Good Parts”的部分内容。我觉得他认为曾经咬过他的一切都是有害的：

关于开关掉线：

我从不允许切换案例落入下一个案例。我曾经在我的代码中发现了一个错误，这是在我发表了关于为什么跌倒有时有用的激烈演讲后立即意外跌倒引起的。 （第 97 页，ISBN 978-0-596-51774-8）

关于 ++ 和 --

众所周知，++（递增）和 --（递减）运算符会通过鼓励过度的技巧来导致糟糕的代码。在启用病毒和其他安全威胁方面，它们仅次于错误的架构。 （第 122 页）

关于新：

如果在调用构造函数时忘记包含 new 前缀，那么 this 将不会绑定到新对象。可悲的是，这将绑定到全局对象，因此您将破坏全局变量，而不是扩充您的新对象。那真的很糟糕。没有编译警告，也没有运行时警告。 （第 49 页）

还有更多，但我希望你能明白。

我对你的问题的回答：不，它没有害处。但是如果你忘记在你应该使用它的时候使用它，你可能会遇到一些问题。如果您在良好的环境中发展，您会注意到这一点。

更新

在编写此答案大约一年后，ECMAScript 的第 5 版发布，支持 strict mode。在严格模式下，this 不再绑定到全局对象，而是绑定到 undefined。

---

Javascript 是动态语言，有无数种方法可以搞砸另一种语言会阻止你的地方。

避免使用诸如 new 之类的基本语言功能可能会造成混乱，这有点像在穿过雷区之前脱掉闪亮的新鞋，以防你的鞋子弄脏。

我使用一个约定，其中函数名称以小写字母开头，而实际上是类定义的“函数”以大写字母开头。结果是一个非常引人注目的视觉线索，表明“语法”是错误的：-

var o = MyClass();  // this is clearly wrong.

除此之外，良好的命名习惯也会有所帮助。毕竟函数都是做事的，因此它的名称中应该有一个动词，而类代表对象并且是没有动词的名词和形容词。

var o = chair() // Executing chair is daft.
var o = createChair() // makes sense.

有趣的是 SO 的语法着色如何解释上面的代码。

---

我是 Javascript 的新手，所以也许我在提供一个好的观点方面经验不足。然而，我想分享我对这个“新”事物的看法。

我来自 C# 世界，在那里使用关键字“new”是如此自然，以至于工厂设计模式对我来说很奇怪。

当我第一次用 Javascript 编写代码时，我没有意识到有“new”关键字和 YUI 模式中的代码，我很快就会遇到灾难。回顾我编写的代码时，我忘记了特定行应该做什么。更混乱的是，当我“空运行”代码时，我的思维无法真正在对象实例边界之间转换。

然后，我找到了对我来说“分离”事物的“新”关键字。使用 new 关键字，它可以创建事物。如果没有 new 关键字，我知道我不会将它与创建事物混淆，除非我调用的函数给了我强有力的线索。

例如，对于 var bar=foo();，我不知道 bar 可能是什么......它是返回值还是新创建的对象？但是对于 var bar = new foo();，我确定 bar 是一个对象。

---

for new 的另一种情况是我所说的Pooh Coding。小熊维尼跟着他的肚子走。我说使用你正在使用的语言，而不是反对它。

语言的维护者很有可能会针对他们试图鼓励的习语优化语言。如果他们将新关键字放入语言中，他们可能认为在创建新实例时明确是有意义的。

按照语言的意图编写的代码将随着每个版本的发布而提高效率。避免语言关键结构的代码会随着时间的推移而受到影响。

编辑：这远远超出了性能。我数不清有多少次我听到（或说过）“他们到底为什么要那样做？”当发现奇怪的代码时。事实证明，在编写代码时，有一些“好的”理由。遵循语言之道是几年后您的代码不会被嘲笑的最佳保险。

---

我写了一篇关于如何缓解在不使用 new 关键字的情况下调用构造函数的问题的帖子。
这主要是说教，但它展示了如何创建使用或不使用 new 且不需要添加的构造函数boilerplate code 在每个构造函数中测试 this。

http://js-bits.blogspot.com/2010/08/constructors-without-using-new.html

以下是该技术的要点：

/**
 * Wraps the passed in constructor so it works with
 * or without the new keyword
 * @param {Function} realCtor The constructor function.
 *    Note that this is going to be wrapped
 *    and should not be used directly 
 */
function ctor(realCtor){
  // This is going to be the actual constructor
  return function wrapperCtor(){
    var obj; // object that will be created
    if (this instanceof wrapperCtor) {
      // Called with new
      obj = this;
    } else {
      // Called without new. Create an empty object of the
      // correct type without running that constructor
      surrogateCtor.prototype = wrapperCtor.prototype;
      obj = new surrogateCtor();
    }
    // Call the real constructor function
    realCtor.apply(obj, arguments);
    return obj;
  }

  function surrogateCtor() {}
}

以下是如何使用它：

// Create our point constructor
Point = ctor(function(x,y){
  this.x = x;
  this.y = y;
});

// This is good
var pt = new Point(20,30);
// This is OK also
var pt2 = Point(20,30);

---

不使用 new 关键字的理由很简单：

通过根本不使用它，您可以避免意外忽略它所带来的陷阱。 YUI 使用的构造模式是如何完全避免使用 new 关键字的示例”

var foo = function () {
    var pub= { };
    return pub;
}
var bar = foo();

或者你可以这样：

function foo() { }
var bar = new foo();

但是这样做会冒着有人忘记使用 new 关键字的风险，并且 this 操作符全是 fubar。 AFAIK 这样做没有任何好处（除了你已经习惯了）。

在一天结束时：这是关于防守的。你能用新的说法吗？是的。它会让你的代码更危险吗？是的。

如果您曾经编写过 C++，这类似于在删除指针后将指针设置为 NULL。

---

我认为“新”增加了代码的清晰度。清晰值得一切。很高兴知道存在陷阱，但通过避免清晰来避免它们对我来说似乎不是这样。

---

案例 1：new 不是必需的，应该避免

var str = new String('asd');  // type: object
var str = String('asd');      // type: string

var num = new Number(12);     // type: object
var num = Number(12);         // type: number

情况2：需要new，否则会报错

new Date().getFullYear();     // correct, returns the current year, i.e. 2010
Date().getFullYear();         // invalid, returns an error

---

以下是我对支持和反对使用 new 运算符的两个最有力论据的最简短总结：

反对新的论据

设计为使用 new 运算符实例化为对象的函数如果被错误地调用为普通函数，可能会产生灾难性的影响。在这种情况下，函数的代码将在调用函数的范围内执行，而不是按预期在本地对象的范围内执行。这可能会导致全局变量和属性被覆盖并带来灾难性后果。最后，编写函数 Func()，然后调用 Func.prototype 并向其添加内容，以便您可以调用 new Func() 来构造对象，这对于一些程序员来说似乎很丑陋，他们宁愿使用另一种对象继承风格来进行架构和风格的原因。

有关此论点的更多信息，请查看 Douglas Crockford 的伟大而简洁的书 Javascript：The Good Parts。事实上，无论如何都要检查一下。

支持新的论据

使用 new 运算符和原型赋值很快。如果您总是在构造函数中包含一些代码以检查它们是否被正确调用，并且在它们没有被正确调用的情况下，那么在全局命名空间中意外运行构造函数代码的事情可以很容易地避免，根据需要适当地处理呼叫。

有关此技术的简单说明以及对他所倡导的继承模型的一般更深入的说明，请参见 John Resig's post。

---

我同意佩斯和一些在这里。

对我来说，“新”似乎很明显是自我描述的对象创建，Greg Dean 描述的 YUI 模式完全被掩盖了。

有人可以在 baz 不是对象创建方法的情况下编写 var bar = foo; 或 var bar = baz(); 的可能性似乎远更危险。

---

我认为 new 是邪恶的，不是因为如果你忘记错误地使用它可能会导致问题，而是因为它搞砸了继承链，使语言更难理解。

JavaScript 是基于原型的面向对象的。因此，每个对象都必须从另一个对象创建，例如 var newObj=Object.create(oldObj)。这里 oldObj 被称为 newObj 的原型（因此是“基于原型的”）。这意味着如果在 newObj 中没有找到一个属性，那么它将在 oldObj 中搜索。 newObj 默认情况下将是一个空对象，但由于其原型链，它似乎具有 oldObj 的所有值。

另一方面，如果您执行 var newObj=new oldObj()，则 newObj 的原型是 oldObj.prototype，这非常难以理解。

诀窍是使用

Object.create=function(proto){
  var F = function(){};
  F.prototype = proto;
  var instance = new F();
  return instance;
};

它在这个函数内部，只有在这里才应该使用 new 。在此之后只需使用 Object.create() 方法。该方法解决了原型问题。

---

IMNSHO“新”是 2021 JavaScript 中的一个有缺陷的概念。它在不需要的地方添加单词。它使函数/构造函数的返回值隐含并强制在函数/构造函数中使用 this。在代码中添加噪音从来都不是一件好事。

// With new
function Point(x, y) {
    this.x = x
    this.y = y
}
let point = new Point(0,0)

比。

// Without new
function Point(x, y) {
    return { x, y }
}
let point = Point(0,0)

---