Ang pangunahing problema sa pagsukat ng oras ng pagpapatakbo ng function ay maaaring mahirap matukoy kung gaano katagal ang isang partikular na function upang maisakatuparan. Ito ay dahil ang oras na kinakailangan para sa isang function upang tumakbo ay maaaring depende sa iba't ibang mga kadahilanan, kabilang ang laki at pagiging kumplikado ng function, ang computer kung saan ito ay pinaandar, at ang bilis ng processor ng computer.
There are many ways to measure the run time of a function in JavaScript. One way is to use the Date object:
function measureFunctionRunTime(func) { var start = new Date().getTime(); func(); var end = new Date().getTime(); return end - start; }
1. Ang function na ito ay tumatagal sa isang parameter na tinatawag na "func" na isang function.
2. Lumilikha ito ng bagong bagay na Petsa at nakukuha ang oras sa milliseconds (getTime()). Ito ang oras ng pagsisimula.
3. Pagkatapos ay pinapatakbo nito ang function na ipinasa bilang isang parameter.
4. Lumilikha ito ng isa pang bagong bagay na Petsa at makakakuha muli ng oras sa mga millisecond (getTime()). Ito ang oras ng pagtatapos.
5. Sa wakas, ibinabalik nito ang pagkakaiba sa pagitan ng oras ng pagtatapos at oras ng pagsisimula (pagtatapos – simula). Nagbibigay ito sa iyo ng oras ng pagtakbo ng function sa milliseconds.
Mga Uri ng Unyon
May tatlong uri ng mga unyon sa JavaScript: mahigpit, maluwag, at implicit.
Ang mga mahigpit na unyon ay ang pinaka mahigpit. Pinapayagan lamang nila ang isang uri ng elemento na isama sa isa pang uri ng elemento. Halimbawa, ang isang mahigpit na unyon sa pagitan ng isang integer at isang string ay magbibigay-daan lamang sa mga integer na pagsamahin sa mga string. Ang mga maluwag na unyon ay hindi gaanong mahigpit kaysa sa mahigpit na mga unyon. Pinapayagan nila ang anumang dalawang uri ng mga elemento na pagsamahin, hangga't ang kumbinasyon ay may katuturan. Halimbawa, ang isang maluwag na pagsasama sa pagitan ng isang integer at isang string ay maaari ding magsama ng mga numero at simbolo. Ang mga implicit na unyon ay ang hindi gaanong mahigpit na uri ng unyon. Pinapayagan nila ang anumang uri ng elemento na isama sa anumang iba pang uri ng elemento, nang hindi kinakailangang tukuyin kung anong uri ng unyon ito. Halimbawa, ang isang implicit na pagsasama sa pagitan ng isang integer at isang string ay maaari ding magsama ng mga numero at simbolo.
Type
Ang pag-type sa JavaScript ay medyo naiiba kaysa sa pag-type sa ibang mga wika. Sa JavaScript, hindi mo kailangang i-type ang kumpletong keyword o pangalan ng function. Maaari mo lamang i-type ang unang titik ng keyword o function at ang natitirang bahagi ng salita ay autocompleted.
Halimbawa, kung gusto mong i-type ang "function", i-type mo lang ang "f" at ang JavaScript ay awtomatikong kumpletuhin ang natitirang salita para sa iyo. Kung gusto mong mag-type ng "alerto", i-type mo lang ang "a" at ang JavaScript ay mag-autocomplete ng natitirang salita para sa iyo.
Uri ng mga Pahiwatig
Ang mga pahiwatig ng uri ay isang tampok ng wikang JavaScript na nagbibigay-daan sa iyong tukuyin ang uri ng isang expression nang hindi kinakailangang gamitin ang uri ng operator. Halimbawa, ipinapahayag ng sumusunod na code na ang variable na x ay isang numero:
var x = 5;
Maaari ka ring gumamit ng mga pahiwatig ng uri kapag tinutukoy mo ang isang function. Halimbawa, ang sumusunod na code ay nagdedeklara ng function na kumukuha ng input parameter ng type number at nagbabalik ng string:
function multiply(x) { return x * x; }
