ECMAScript 修改对象

ECMAScript ఉపయోగించడం ద్వారా, పద్ధతులను సృష్టించవచ్చు మరియు ప్రస్తుత పద్ధతుల ప్రవర్తనను మార్చవచ్చు.

prototype అనే లక్షణం కన్నా కొన్ని కన్స్ట్రక్టర్ లక్షణాలు మరియు పద్ధతులను నిర్వచించవచ్చు, అలాగే స్థానిక పద్ధతులను కూడా జోడించవచ్చు.

创建新方法

通过已有的方法创建新方法

可以用 prototype 属性为任何已有的类定义新方法，就像处理自己的类一样。例如，还记得 Number 类的 toString() 方法吗？如果给它传递参数 16，它将输出十六进制的字符串。如果这个方法的参数是 2，那么它将输出二进制的字符串。我们可以创建一个方法，可以把数字对象直接转换为十六进制字符串。创建这个方法非常简单：

Number.prototype.toHexString = function() {
  return this.toString(16);
};

在此环境中，关键字 this 指向 Number 的实例，因此可完全访问 Number 的所有方法。有了这段代码，可实现下面的操作：

var iNum = 15;
alert(iNum.toHexString());		//输出 "F"

TIY

由于数字 15 等于十六进制中的 F，因此警告将显示 "F"。

重命名已有方法

我们还可以为已有的方法命名更易懂的名称。例如，可以给 Array 类添加两个方法 enqueue() 和 dequeue()，只让它们反复调用已有的 push() 和 shift() 方法即可：

Array.prototype.enqueue = function(vItem) {
  this.push(vItem);
};
Array.prototype.dequeue = function() {
  return this.shift();
};

TIY

添加与已有方法无关的方法

当然，还可以添加与已有方法无关的方法。例如，假设要判断某个项在数组中的位置，没有本地方法可以做这种事情。我们可以轻松地创建下面的方法：

Array.prototype.indexOf = function (vItem) {
  for (var i=0; i

该方法 indexOf() 与 String 类的同名方法保持一致，在数组中检索每个项，直到发现与传进来的项相同的项目为止。如果找到相同的项，则返回该项的位置，否则，返回 -1。有了这种定义，我们可以编写下面的代码：


var aColors = new Array("red","green","blue");
alert(aColors.indexOf("green"));	//అవుతుంది "1"



TIY


స్థానిక ఆబ్జెక్ట్స్కు కొత్త మెథడ్స్ జోడించడం


ఫినాలే, ECMAScript లోని ప్రతి స్థానిక ఆబ్జెక్ట్కు కొత్త మెథడ్స్ జోడించడానికి, అది Object ఆబ్జెక్ట్ యొక్క prototype అంశంపై నిర్వహించాలి. ముంది చాప్టర్లో చెప్పినట్లు, అన్ని స్థానిక ఆబ్జెక్ట్స్ Object ఆబ్జెక్ట్ నుండి సంకలించబడినవి, కాబట్టి Object ఆబ్జెక్ట్పై ఏ మార్పును చేసినా, అన్ని స్థానిక ఆబ్జెక్ట్స్ పై ప్రతిస్పందిస్తుంది. ఉదాహరణకు, ఒక అసలు ఆబ్జెక్ట్ యొక్క ప్రస్తుత విలువను వార్నింగ్ చేయడానికి కొత్త మెథడ్ జోడించవచ్చు అనే కోడ్ ఈ కింది విధంగా ఉంటుంది:


Object.prototype.showValue = function () {
  alert(this.valueOf());
};
var str = "hello";
var iNum = 25;
str.showValue();		//అవుతుంది "hello"
iNum.showValue();		//అవుతుంది "25"



TIY


ఇక్కడ, String మరియు Number ఆబ్జెక్ట్స్ Object ఆబ్జెక్ట్ నుండి showValue() మెథడ్ సంకలించబడినవి, వాటి ఆబ్జెక్ట్స్ పై ఈ మెథడ్ను కాల్ చేసినప్పుడు, "hello" మరియు "25" ప్రదర్శించబడతాయి.

అసలు మెథడ్స్ నిర్వహించడం

ఇదే విధంగా, ప్రస్తుతం అసలు క్లాస్లకు కొత్త మెథడ్స్ నిర్వహించవచ్చు. ముంది చాప్టర్లో చెప్పినట్లు, ఫంక్షన్ పేరు ఫంక్షన్ యొక్క పాయింటర్ గా ఉంటుంది, కాబట్టి సులభంగా మరొక ఫంక్షన్ ను సూచించవచ్చు. స్థానిక మెథడ్స్, మేలా toString() మార్చినప్పుడు ఏమి జరుగుతుంది? అది ఏమి జరుగుతుంది?

Function.prototype.toString = function() {
  return "Function code hidden";
}

ఈ కోడ్ పూర్తిగా చట్టబద్ధం, అనుభవించిన ఫలితం పూర్తిగా అనుకున్న అనుకూలంగా ఉంటుంది:

function sayHi() {
  alert("hi");
}
alert(sayHi.toString());	//అవుతుంది "Function code hidden"

TIY

మీరు గుర్తించగలరు, Function ఆబ్జెక్ట్ ఈ చాప్టర్లో Function యొక్క toString() మెథడ్ సాధారణంగా ఫంక్షన్ యొక్క స్రవంతి కోడ్ అవుతుంది. ఈ మెథడ్ను అధిగమించడం ద్వారా మరొక స్ట్రింగ్ అవుతుంది (ఈ ఉదాహరణలో, "Function code hidden" అవుతుంది). కానీ, toString() సూచించే అసలు ఫంక్షన్ ఏమి జరిగింది? అది పూర్తిగా ఉపయోగించబడని స్టోరేజ్ యూనిట్లో తిరిగి పొందబడుతుంది. అసలు ఫంక్షన్ ను పునరుద్ధరించడానికి ఏ మార్గం లేదు, కాబట్టి అసలు మెథడ్ను అధిగమించడానికి ముందు దాని పాయింటర్ను నిల్వ చేయడం చాలా సురక్షితం. కొన్నిసార్లు మీరు కూడా నూతన మెథడ్లో అసలు మెథడ్ను కాల్ చేయవచ్చు:

Function.prototype.originalToString = Function.prototype.toString;
Function.prototype.toString = function() {
  if (this.originalToString().length > 100) {
    return "Function too long to display.";
  } else {
    return this.originalToString();
  }
};

TIY

ఈ కోడ్ లో, మొదటి లైన్ ప్రస్తుత �toString() పద్ధతికి సూచకాన్ని ప్రారంభ ప్రాణికి చేరుస్తుంది. అప్పటికే ప్రత్యేక పద్ధతిని toString() పద్ధతిపై ఆధారపడి రాయబడింది. కొత్త పద్ధతి ఫంక్షన్ సొరంగం పొడవును పరిశీలిస్తుంది. ఉన్నది కంటే అధికం అయితే, ఫంక్షన్ సొరంగం పొడవు కాకపోయినప్పుడు, ఫంక్షన్ సొరంగం పొడవు కాకపోయినట్లు సూచించే పత్రికను తిరిగి చేస్తుంది, మరియు originalToString() పద్ధతిని కాల్పనికంగా అనువందిస్తుంది మరియు ఫంక్షన్ సొరంగం పొడవును తిరిగి చేస్తుంది.

అత్యంత తక్కువ బ్యాండ్లింగ్ (Very Late Binding)

సాంకేతికంగా, అత్యంత తక్కువ బ్యాండ్లింగ్ లేదు. ఈ పుస్తకం ఈ పదాన్ని ECMAScriptలో ఒక ఫెనోమెనా వర్ణించడానికి ఉపయోగిస్తుంది, అది ఆబ్జెక్ట్ సృష్టించిన తర్వాత తన పద్ధతులను నిర్వచించగలదు. ఉదాహరణకు:

var o = new Object();
Object.prototype.sayHi = function () {
  alert("hi");
};
o.sayHi();

TIY

అత్యంత ప్రధాన ప్రోగ్రామింగ్ భాషలలో ప్రధానంగా, ఆబ్జెక్ట్ నిర్వచించడానికి ముందు ఆబ్జెక్ట్ పద్ధతులను నిర్వచించాలి. ఇక్కడ, sayHi() పద్ధతి Object క్లాస్ ఒక ఉదాహరణను సృష్టించిన తర్వాత జోడించబడింది. కాల్పనిక భాషలలో ఈ చర్యను చేరుకోలేదు, అలాగే ఈ పద్ధతి ఆబ్జెక్ట్ క్లాస్ ఉదాహరణకు స్వయంచాలకంగా అనువందించబడింది మరియు తక్కువ మేరకు ఉపయోగించబడింది (తరువాత ఒక పంక్తి).

మీరు అందరికీ మేరు:అత్యంత తక్కువ బ్యాండ్లింగ్ పద్ధతిని ఉపయోగించకుండా నిర్ణయించబడింది, ఎందుకంటే దానిని పరిశీలించడం మరియు రికార్డు చేయడం చాలా కష్టం. అయితే, ఈ ప్రమాణాన్ని తెలుసుకోవాలి.