Modifying Objects in ECMAScript

Sa pamamagitan ng paggamit ng ECMAScript, hindi lamang maaaring gumawa ng mga object, kundi maaari rin nang baguhin ang pag-uugali ng mga umiiral na object.

Ang prototype na katangian ay hindi lamang nagbibigay ng kapangyarihan sa paglalarawan ng mga attribute at method ng constructor, kundi ito ay nagpapahintulot sa lokal na object na magdagdag ng mga attribute at method.

Gumawa ng bagong method

Gumawa ng bagong method sa pamamagitan ng mga mayroon na method

Maaaring gamitin ang prototype attribute upang idefinin ang bagong method para sa anumang mayroon na klase, tulad ng pagtrato ng sarili nitong klase. Halimbawa, maalala mo ba ang method na toString() ng klase ng Number? Kung ibibigay ang argumento na 16, ito ay magpapakita ng heksadecimal string. Kung ang argumento ay 2, ito ay magpapakita ng binary string. Maaari naming bumuo ng isang method na maaaring konbertihin ang numero object sa heksadecimal string. Madali itong gumawa ng ganitong method:

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

Sa ganitong kapaligiran, ang keyword na this ay tumutukoy sa instance ng Number, kaya buong akses sa lahat ng method ng Number. Sa pamamagitan ng ganitong code, maaari naming gawin ang sumusunod na operasyon:

var iNum = 15;
alert(iNum.toHexString());		// Magpakita ng 'F'

TIY

Dahil ang numero 15 ay katumbas ng 'F' sa heksadecimal, ang babala ay magpapakita ng 'F'.

Muling maglagay ng pangalan sa mga mayroon na method

Maaari rin naming maglagay ng mas madaling maunawaang pangalan sa mga mayroon na method. Halimbawa, maaari naming idagdag sa klase ng Array ang dalawang method na enqueue() at dequeue(), na dapat gumagamit lamang ng mga mayroon na method na push() at shift():

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

TIY

Magdagdag ng mga method na hindi kaugnay sa mayroon na method

Nakakaintindihan din na magdagdag ng mga method na hindi kaugnay sa mga mayroon na method. Halimbawa, kung gusto mong matukoy ang posisyon ng isang item sa array, walang lokal na method na pwedeng gawin ito. Maaari naming madagdagan ang sumusunod na method:

Array.prototype.indexOf = function (vItem) {
  para (var i=0; i<this.length; i++) {
    kung (vItem == this[i]) {
	  return i;
	}
  }
  return -1;
}

Ang paghahanap ng indexOf() ay katulad sa katulad na method ng String class, inihahanap ang bawat item sa array hanggang sa makita ang katumbas ng ipinapasa na item. Kung mayroon ang katumbas na item, ibibigay ang posisyon nito, kung hindi, ibibigay ang -1. Sa ganitong kahulugan, maaari naming isulat ang sumusunod na code:

var aColors = new Array("red","green","blue");
alert(aColors.indexOf("green"));	// magluluto "1"

TIY

Magdagdag ng bagong method sa lokal na object

Sa wakas, kung gusto mong magdagdag ng bagong method sa bawat lokal na object sa ECMAScript, dapat mong i-definir ito sa attribute na prototype ng object na Object. Tulad ng sinabi sa nakaraang chapter, lahat ng lokal na object ay minana ang object na Object, kaya anumang pagbabago sa object na Object ay makikita sa lahat ng lokal na object. Halimbawa, kung gusto mong magdagdag ng isang method na magpopoposisyon ng kasalukuyang halaga ng object, maaaring gamitin ang sumusunod na code:

Object.prototype.showValue = function () {
  alert(this.valueOf());
};
var str = "hello";
var iNum = 25;
str.showValue();		// magluluto "hello"
iNum.showValue();		// magluluto "25"

TIY

Dito, ang mga object na String at Number ay minana ang method na showValue() mula sa object na Object, at tinatawag ang method sa kanilang mga object, magpapakita ng "hello" at "25".

Muling itulak ang umiiral na method

Tulad ng maaring maglagay ng bagong method sa umiiral na klase, maaari ring muling itulak ang umiiral na method. Tulad ng sinasabi sa nakaraang chapter, ang pangalan ng function ay lamang ang pointer na tumutukoy sa function, kaya madaling mapunta sa ibang function. Kung napagpalit ang lokal na method, tulad ng toString(), anong mangyayari?

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

Ang nakaraang code ay ganap na lehitimo, ang resulta ng paglatakbo ay ganap na ayon sa inaasahan:

function sayHi() {
  alert("hi");
}
alert(sayHi.toString());	// magluluto "Function code hidden"

TIY

Maari mong alalahanin, ang Function object na pinakasalita sa kaniyang chapter ay ang toString() method ay karaniwang nagluluto ng pinagmulan ng source code ng function. Pagpapatuloy sa method, maaaring ibalik ang ibang string (sa kasong ito, maaaring ibalik "Function code hidden"). Gayunman, kung ano ang nangyari sa orihinal na function na tinutukoy ng toString()? Ito ay aalisin ng programang naglilinis ng walang silbi na storage unit, dahil ito ay lubos na nilabutan. Walang paraan upang mabawi ang orihinal na function, kaya mas ligtas na mag-imbak ng pointer nito bago i-overwrite ang orihinal na method para sa hinaharap na paggamit. Maaari mo ring tumawag sa orihinal na method sa bagong method:

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

TIY

Sa kodong ito, ang unang linya ay inilalagay ang pagtutukoy sa kasalukuyang toString() na pinanatili sa atributo ng originalToString. Pagkatapos, inilagay ang sariling paraan sa toString() na pinag-over sa toString() na paraan. Ang bagong paraan ay gagawin ng pagsusuri kung ang haba ng pinagmulan ng kode ng function ay higit sa 100. Kung ito, ibibigay ang mensahe ng error na nagsasabi na ang kode ng function ay napakalamang, kung hindi ibibigay ang originalToString() na paraan at ibibigay ang pinagmulan ng kode ng function.

Pinakalamang pagkakabit (Very Late Binding)

Technically speaking, walang kahit anong pagkakabit na pinakalamang. Ang aklat na ito ay gumagamit ng terminong ito para ilarawan ang isang pinagmulan ng ECMAScript, na nagbibigay-daan upang tukuyin ang mga paraan ng bagay pagkatapos ng pagtataya ng bagay. Halimbawa:

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

TIY

Sa karamihan ng mga wika ng pagprogramahan, dapat ituring ang mga paraan ng bagay bago maisagawa ang pagtataya ng bagay. Dito, ang paraan na sayHi() ay idinagdag pagkatapos ng paglikha ng isang instance ng klase Object. Sa tradisyonal na wika, hindi na nakikilala ang operasyon na ito, at hindi rin nakikilala na ang paraan na ito ay awtomatikong ipinagbigay sa instance ng bagay na Object at maaaring agad gamitin (sa susunod na linya).

Babala:Hindi maaring gamitin ang pinakalamang pagkakabit na pamamaraan, dahil mahirap itong subaybayan at talaan. Gayunman, dapat naiintindihan ang posibleng ganito.