在 JavaScript 中隐式地将方法添加到构造函数的原型中

Question

以下是

来自Crockford的JavaScript的代码片段： The Good Parts：

Function.prototype.method = function (name, func) {
  this.prototype[name] = func;
  return this;
};

克

罗克福德继续解释说

"通过使用方法方法增强Function.prototype，我们不再 必须键入原型属性的名称。那一点丑陋 现在可以隐藏了。

我基本上不明白这一点。 我们以前必须做什么，现在我们不再需要做什么？

Answer 1

他说的不是写：

MyType.prototype.myMethod = function() {
    ..
};

你可以这样写：

MyType.method("myMethod", function() {
    ...
});

有可能（给定return this）点链接另一个调用：

MyType.method("method1", function() {
    ...
}).method("method2", function() {
    ...
});

唉。

Answer 2

代码分解：

Function.prototype.method

JavaScript 中的每个对象都允许原型。这是JavaScript的继承方式。函数是创建所有其他函数的master object。当您在其上设置原型时，所有函数对象都会继承该属性。在这种情况下，函数method 。

 Function.prototype.method= function (name, func) {
     this.prototype[name] = func;
     return this;
 };

如果您想使用其他方法扩展自己的functions，则需要键入：

  somefunction.prototype.name = function(){}

使用此方法，您可以执行以下操作：

  somefunction.method(name, function)

这个时髦的位是这样做的：

  this.prototype[name] = func;

它使用 this 关键字引用函数对象。进行继承的原型。使用 [name] 将函数设置为原型。这会将字符串名称转换为属性。为什么会这样？因为：

 this.prototype.name 

无法正常工作。如果您使用上面的代码，则每次添加新method时，name都会引用它，而不是您选择的名称。

为什么prototype[example]和原型一样。因为在 JavaScript 中，每个属性都存储在对象的数组列表中，并且可以像使用 Object[] 从数组中调用项一样调用。

Answer 3

让我们证明科克福德的说法：

"通过用方法方法增强Function.prototype，我们没有 更长必须键入原型属性的名称。那一点 丑陋现在可以隐藏了。

在这里，crockford想说的是，你可以操纵Function.prototype来实现许多不同的功能供你个人使用。它是添加到 function.prototype 的一项功能，用于向任何函数添加新方法/属性。javascript 中的函数继承了 Function.prototype.let 分解你的代码。

Function.prototype.method = function （name， func） {

在这一行中，Function.prototype添加了一个新方法。此方法接收两个参数。name新方法名称的 satands 。func代表其功能。我想你熟悉什么是方法和属性。函数是 JavaScript 中的第一类对象。因此，可以在运行时添加新的属性和方法。

this.prototype[name] = func;

这里指的是调用它的函数。[name]是方法名称，func是方法的功能 它使用数组表示法向传递的函数添加了一个新方法。然后最后

返回此;

使用此语句返回传递的函数，并向其中添加一个新方法。

在这里，我为您提供一个实际示例：

Function.prototype.method = function (name, func) {
this.prototype[name] = func;
return this;
};
function Myfunction(){       // a constructor function called Myfunction
    this.name='robin';      // it has a name property
}
Myfunction.method('mymethod',function (){ console.log(' i am available')});  //adds a method named 'mymethod to Myfunction constructor
var newObj=new Myfunction();     // creates a new instance  of Myfunction class
console.log(newObj.mymethod());  //calls mymethod() of newObj

这里myfunction是一个构造函数。我们可以将继承的方法添加到此构造函数的原型中Myfunction.prototype.mymethod=function(){ ..}

如果你使用 myfunction 作为构造函数，这就是你向其添加方法的方式。但是当你在 Function.prototype 中添加了一个新功能时，你可以简单地称之为

Myfunction.method('mymethod',function (){console.log('i am available'}); //it will add a method named mymethod to Myfunction's prototype 

此语句将添加一个名为 mymethod 的新方法，以隐式Myfunction()'s prototype。

所以你不必写Myfunction.prototype.mymethod=function(){ console.log('i am available');.相反，您可以编写Myfunction.method('mymethod',function (){ console.log('i am available'});

因此，它证明每次您想向 Myfunction 构造函数添加新方法时，它都会让您免于一次又一次地编写Myfunction.prototype。

所以它证明了克罗克福德的说法。