在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的繼承方式。 Function是創建所有其他函數的master object 。 在其上設置原型時，所有Function對象都繼承該屬性。 在這種情況下的功能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關鍵字引用Function對象。 繼承原型的收益。 使用[name]將函數設置為原型。 這會將字符串名稱轉換為屬性。 為什么這樣？ 因為：

 this.prototype.name 

不會正常工作。 如果您使用上面的代碼，每次添加新method ，它都將按name引用，而不是您選擇的名稱。

為什么prototype[example]與prototype.example相同。 因為在JavaScript中，每個屬性都存儲在對象的數組列表中，並且可以像使用Object []從數組中調用項目一樣進行調用。

Answer 3

讓我們證明corckford的聲明：

“通過使用方法方法擴充Function.prototype，我們不再需要輸入原型屬性的名稱。現在可以隱藏這一點丑陋。”

在這里，crockford想說你可以操作Function.prototype來為你的個人用途實現許多不同的功能。它是一個添加到function.prototype的功能，用於向任何函數添加新的方法/屬性.javascript中的函數繼承形式Function.prototype。讓我們分解您的代碼。

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是一個構造函數。我們可以將繼承的方法添加到這個構造函數的原型usind 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 

這個語句將隱式地向Myfunction()'s prototype添加一個名為mymethod的新方法。

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

所以它證明每次你想要向Myfunction構造函數添加新方法時，它會一次又一次地編寫Myfunction.prototype 。

所以它證明了克羅克福德的說法。