JavaScript: function na function. Programming language JS

Ideya dynamic na nilalaman upang bumuo ng mga web-RESOURCES ay naging ang mga pamantayan. Static na mga pahina at mga template Web disenyo sa wakas ay nakumpleto ang kanilang misyon.

Gayunpaman, modernong web-resource ay hindi kailangang katawanin ng isang hanay ng mga pahina na nalikha sa pamamagitan ng mga server at i-refresh ang browser (JS + AJAX).

Web-based na imbakan sa sandaling ito ng pagdating ng mga bisita ay maaaring maging isang pares ng mga pamagat para sa rekord, ang ilang mga teksto sa «head», ng ilang linya ng code sa «katawan» at lahat. Ang natitirang bahagi ng "maglarawan sa isip" sa proseso ng bisita - ito ay isang perpektong site, o mga nagnanais na maging isa.

Ilagay ang mga paglalarawan at likas na katangian ng pag-andar

опыт, наработаный многими десятилетиями. JavaScript - ito ay isang karanasan narabotany dekada. Ito ay may isang makabuluhang kasaysayan ng pag-unlad, modernong mga kwalipikadong koponan ng mga tagalikha developer. Wika mahusay na naisip out, maaasahan, maganda at nagbibigay ng isang tunay na pagkakataon para sa mga developer na magsulat ng code para sa isang disente at self-pagpapabuti.

Ang konsepto ng isang algorithm ay isang function dito ay hindi umiiral sa prinsipyo. Of course, ang nag-develop ay maaaring saanman sa pahina sa magpasok ng script code sa ilagay sa ito at ito ay pinaandar. страницы? Ngunit ano ay ang punto sa code, na kung saan ay pinaandar isang beses lamang: kapag naglo-load (load muli) sa pahina? Posible upang itakda ang paunang halaga ng kung ano ang ilang mga hindi gaanong mahalaga variable.

Script - ang lugar na ito ay ang tamang paglalarawan ng mga variable at mga function, sa halip na isang mahusay na piraso ng code na isinulat para sa kanyang sariling kapakanan. Ito ay isang hanay ng mga function ay mahalaga at mahalaga, marahil - ang kanilang mutual direktang koneksyon, ngunit mas madalas ito ay naiiba. Lugar paglalarawan ng mga function at mga lugar ng application nito ay hindi ang parehong bagay.

Ito ay hindi kinakailangan na ang function ay tumawag ng isa pang pag-andar nang direkta, ngunit maaari itong gawin hindi direkta sa pamamagitan ng mga pormasyon ng mga dynamic na code. Ang isang bisita ay tumatagal ng isang desisyon sa loob ng ang code na ito at gumagana lubos na iba't-ibang mga pag-andar ng sistema.

functional dynamics

Functional dynamics - ay hindi lamang at hindi kaya magkano handler na nakatalaga sa mga sangkap ng pahina ay mga pag-andar na bumubuo sa mga sangkap ng pahina, at sa mga kagyat na handler, masyadong, ay maaaring magbago.

Ang aksyon ay tumatagal ng lugar sa pahina, depende sa ang mga elemento at pag-uugali ng bisita sa ito. Movement ng mouse, keyboard, mga pindutan, mga pag-click, mga kaganapan, mga item at iba pang mga pangyayari na humantong sa ang paglunsad ng ang mga kinakailangang function.

Orihinal na walang pagbabago at walang parallel. May ay isang sapat na tugon sa mga kaganapan web-mapagkukunan. Kung gaano kabilis ang JavaScript fulfills isang partikular na function na ito ay nakasalalay sa maraming mga teknikal na (computer, mga linya ng komunikasyon) at semantic (logic algorithm, paksa na lugar, ibig sabihin ang problema) mga kadahilanan.

Sa katunayan maaari itong Nagtalo na ang isang bagay ay nagtrabaho sa parallel, ngunit ang isang bagay ay magpapasara sa matapos ang isang bagay, ngunit ang kahulugan ng mga ito espesyal na ay hindi. Ito ay mahalaga na ang mga function na JavaScript - ito ay isang pagkakataon upang lumikha ng isang sapat na tugon sa mga pagkilos ng bisita.

Ang bagong pag-iisip sa disenyo: ipinamamahagi sa pagpoproseso ng sa kailaliman ng isang solong browser!

Ang syntax para sa mga variable at mga function

JavaScript variable ay inilagay sa mga tag «script», at sa katawan ng function. Function ay tinukoy sa parehong paraan. Espesyal na kahulugan na magsulat sa loob ng function na mayroong isa pang pag-andar, ngunit maaaring ito ay kinakailangan para sa iba't ibang dahilan, at ito ay lubos na makatwiran.

Paglalarawan ng ang pag-andar sa pangkalahatan ay nagsisimula sa mga keyword «function na», na sinusundan ng pangalan nito, ang listahan ng mga argumento sa mga panaklong, na pinaghihiwalay ng mga kuwit, at ang function katawan sa braces.

Sa halimbawang ito, ang dalawang mga function ay inilarawan na nagbibigay ng AJAX-palitan sa pagitan ng pahina at ang server. Bahagyang scXHR inilarawan sa itaas, dahil magagamit sa parehong InitXML, at sa loob ng WaitReplySC.

Ang function na pangalan at parameter na "function na"

May ay nagpakita ang asynchronous na bersyon kapag ang JavaScript-function function ay tinatawag na matapos ang tugon ng server. Kaya, sa pagtanggap ng isang tugon mula sa server, WaitReplySC-a-access ang pahina ng tag, pinupuno ang impormasyon na natanggap at nagiging sanhi ng iba pang mga function, na maaaring na rin simulan ang susunod na kahilingan sa server.

Narito ito rin ay mahalaga na tandaan na WaitReplySC - isang function. scXHR.onreadystatechange = WaitReplySC она передается как параметр. Ngunit sa linya scXHR.onreadystatechange = WaitReplySC ito ay naipasa bilang isang parameter. Ito pangkalahatang panuntunan transfer function sa iba pang mga function tulad ng mga parameter. Matulis na bracket at binigyan sila ng parameter nito (s) - ang function ay pinaandar kaagad. Narrated sa pamamagitan ng pangalan lamang, well kaya kung ano. Call function na ito at gumawa ng isa na got ang kanyang pangalan.

Ang pag-andar ipinatupad sa pamamagitan ng AJAX, ay nagbibigay-daan sa iyo upang tumawag sa isang JavaScript function na sa pamamagitan ng mga data na natanggap mula sa server. Sa katunayan, ang pagpapadala ng isang kahilingan sa server, ang isa o ang iba pang mga tampok na ito ay maaaring hindi sa lahat ng "alam" kung saan gumana siya lumiliko, at kung anong impormasyon.

Out function at ang resulta nito

Ang katawan ng pag-andar, maaari mong isulat ang anumang operator wika, na, sa katunayan, para sa mga ito ay inilaan. Inside tampok ay mga variable na ipinahayag sa loob at sa labas, ngunit hindi ang mga na ay inilarawan sa iba pang mga function.

Kung nais mong ang pag-andar upang bumalik isang resulta, maaari mong gamitin ang JavaScript return pahayag: return. Ang katawan ng pag-andar ay maaaring maging isang sapat na bilang ng mga return pahayag. Ito ay hindi kinakailangan na ang lahat ng mga ito ay babalik ang resulta ng parehong uri.

Karaniwan, ang mga developer ay revered ang pagkakataong ito at, depende sa sitwasyon, nagpasya upang bawiin mula sa mga pag-andar sa lalong madaling panahon.

Ito ay hindi kinakailangan upang tumakbo sa pamamagitan ng buong algorithm ng pag-andar, kapag maaari kang makakuha ng out mas maaga.

argumento ng function

Argumento ay dumaan sa listahan function, na pinaghihiwalay ng mga kuwit, ay nakapaloob sa panaklong, at ay lamang matapos ang kanyang pangalan. Ang mga argumento na ginagamit mga pangalan ng variable, ngunit maaari mong ipasa ang mga halaga ng direkta. Upang pumasa sa isang function ng JavaScript sa isang function, kailangan mo lamang na tukuyin ang pangalan nito nang walang mga bracket.

Inside ang function ay magagamit variable argumento, na may isang haba ng ari-arian. Maaari mong sumangguni sa anumang argumento na function sa pamamagitan ng mga argumento [0], argumento [1], ... sa huling argumento [arguments.length-1].

Ang pagbabago ng pag-andar ng ang argument ay talagang sa loob ng function ngunit hindi sa labas nito. Upang baguhin ang isang bagay sa labas ng function, ang operator ay dapat gumamit ng return JavaScript, kung saan pumasa ang mga kinakailangang mga halaga sa labas.

Matapos ang pag-andar tatapusin, ang lahat na nauugnay sa pagpapatupad nito, ay nawasak. Sa panahon ng pagpapatupad ng pag-andar ay maaaring baguhin ang mga panlabas na mga variable, maliban sa mga na ay inilarawan sa iba pang mga pag-andar, kabilang ang mga nasa interior.

Mayroon kaming mga argumento callee ari-arian, na kung saan ay inilaan upang tumawag sa isang function na ay ginanap sa isang ibinigay na oras. Kung ang sanhi mismo, ang JavaScript bersyon ng function na sa ang pag-andar ay ipatupad recursion.

Ang paggamit ng mga pag-andar

Ang pangunahing pag-aalala ng mga function - upang maghatid ng kaganapan browser. Upang gawin ito halos araw tag ay may kakayahan na tukuyin ang isang pangalan ng kaganapan at pag-andar ng kanyang manufacturing. Maaari mong tukuyin ang maramihang mga kaganapan, ngunit ang bawat kaganapan ay ipinahiwatig lamang ng isang function.

Isang pag-andar ay maaaring panghawakan ang maramihang mga elemento ng pahina at ilang mga kaganapan. Sa pamamagitan ng «ito» pagpipiliang ito, maaari mong ilipat ang impormasyon function na kung saan ito ay tinatawag na.

Ang classic na paggamit ng JS-andar - ang mga humahawak ng kaganapan sa mga elemento. Sa halimbawang ito scfWecomeGo () function o scfWelcomeCancel () ay tinatawag sa input / output anyo ng mga bisita, at kapag pagpili ng operating mode scfMenuItemClick (ito).

Sa huli kaso, ang mga parameter na lumipas na «ito», na kung saan ay nagbibigay-daan sa iyo upang miraculously matuto mula sa kung ano ang diva ay tinawag. Sa totoo lang, JavaScript ay kaya kalitatibong implanted sa DOM, at ito ay kaya Maginhawang nagbibigay-daan sa iyo upang mag-navigate sa mga elemento nito, upang mangolekta ng mga kinakailangang impormasyon na ang mga pahina dynamics maaari lamang maging unpredictable.

Ang function na ay hindi kailangang bumalik ang isang string, numero, o iba pang mga function. Maaari itong ibalik ng isang buong HTML-element, at kung saan ay ang kinakailangang bilang ng mga sangkap, sa kanilang handler, ang kanilang mga kaganapan.

Sa pamamagitan ng paglalagay ng elemento sa pahina, ang nag-develop ay lumilikha ng isang bagong pag-andar na ay mabuti sa mga tuntunin ng pag-solve ang problema at matugunan ang mga hilig ng mga bisita, ngunit medyo mahirap sa mga tuntunin ng pagpapatupad.

Dahil ang pag-unlad ng tulad ng isang fully functional, madaling mawala sa native na code, sa function na tawag, sa mga sandali kapag nabuo o na ang nilalaman ng isa o ng iba pang bahagi ng pahina. Bago ang pagkuha ng ganoong direksyon ng pag-unlad, hindi pumipigil sa well timbangin ang lahat.

Sa pamamahagi ng pag-iisip

developer ay may mag-isip sa antas ng lahat ng mga elemento ng pahina, sa lahat ng mga kaganapan, at magkaroon ng isang malinaw na pagtatanghal ng kung paano ang lahat ng bagay talaga ang mangyayari. Ito ay mahirap, ngunit ang trabaho ay nagkakahalaga ito.

Sa JavaScript, ang pag-andar ay maaaring maantala hanggang ang ilang mga kaganapan, at naturang mga tampok ay maaaring marami, at mga kaganapan ay may isang ugali upang maikalat at kumuha sa ang "sphere of visibility" ng iba't-ibang mga processors.

Sa halimbawang ito, sa isang lugar bago ang function ay tinatawag na, na kung saan pinasimulan ang isang item file menu ng nabigasyon. Ito ay ipinapalagay paging, na nasa window file pitong lang, na kung saan ay maaaring alisin at naproseso. Maaaring ilipat bilang isang file sa pamamagitan ng pag-click sa hilera, at ang mga arrow key at mga bloke ng pitong hilera.

Sa bawat kaso ay may sariling function. Sa ibang salita, sa simpleng halimbawa, kailangan mong magsulat ng isang pares ng mga dose-dosenang mga tampok na reaksyon sa iba't-ibang mga kaganapan, at ang ilan sa mga pag-andar ay mahawakan ng iba't-ibang mga pagpipilian at mga sitwasyon na ang mga kaganapan ay hindi pag-aari.

Halimbawa, kapag pag-alis sa ilalim na linya ay dapat na displaced upwardly. Ito ay mangangailangan ng alinman gumawa ng isang bagong pagpipilian na palasak at malinaw na ang isang mapagkukunan, o upang mabilang na mga linya, gumamit ng javascript function sa array at upang makamit ang layunin elegante.

Ang mga argumento at mga resulta ng mga pag-andar

ay nagbibigay-daan JavaScript iyo na dalhin ang code sa "buong-tampok na" kalagayan. Karaniwan, kapag ang argument ng pag-andar ay ang function. Pinayagan na opsyon, ang function ay nagbabalik ng isang function. JavaScript ay tumatagal ito medyo mahinahon.

Ito ay isang mahusay na mekanismo, ngunit sa halip kumplikado na may kaugnayan sa pagpapatupad. Technically pinapayagan semantically ay nagbibigay ng "functional" logic paghahatid lamang ng isang kwalipikadong developer.

Kapag ang isang function na JavaScript sa isang function - ang lahat ng karapatan, ngunit kapag ang pag-andar ay bumubuo ng isang function, at na isa pa, ang logic ay lubos na mahirap upang sundan. Sa katunayan, ang tanong ay hindi kung upang ilapat ang mga kasanayan, ang tanong ay upang makakuha ng ligtas at tamang resulta.

pangangalaga Developer ay malinaw at simple. May problema, kailangan mo ng solusyon, hindi isang bug tulad ng «JavaScript error sa operasyon ay hindi secure» , isang blangkong screen, o ihinto ang lahat ng browser engine.

Kung ang argument ay isang function, pagkatapos ay ang nag-develop upang pumasa sa isang variable na may espesyal na mga katangian, iyon ay hindi isang numero, hindi isang string, hindi isang bagay. Ngunit ang paggamit ng mga tulad ng isang argument ay maaaring humantong sa ang katunayan na baguhin ang mga panlabas na mga variable at ay ang resulta ng pag-andar execution. Depende sa mga pagbabago na magiging sapat na mailipat.

Pagpapatupad ng mga nalikhang code

Ipatupad ang execution code na binuo sa kurso ng trabaho sa iba pang mga code, ito ay posible sa pamamagitan ng «eval». Ito ay hindi itinuturing na isang mahusay na solusyon, ngunit madalas na hindi maaaring palubhain ang code sa mga hindi kinakailangang pag-andar, at upang limitahan ang pagbuo ng trivia linya ng code ng JavaScript at simpleng-execute ito.

Sa halimbawang ito, ang insert ay nabuo stitch sa umaandar div ilang impormasyon. Diva at impormasyon ng nilalaman para sa iba't ibang bilang ng iba't ibang mga posisyon, dahil tulad ng isang desisyon sa sitwasyong ito ay hindi nagbibigay ng isang garantisadong sitwasyon «javascript error sa operasyon ay hindi secure» , ngunit matatag bigyan ang nais na effect.

Pananarinari JavaScript paradaym paghahalili "function sa ang function na"

Kung maaari mong gawin nang walang frills, ito ay mas mahusay na gamitin ito. Ang lahat ng mga pagpipiliang ito ay mabuti. Of course, sa maraming kaso, ito ay ang tanging solusyon.

Ang isang klasikong halimbawa ng recursion: ang factorial. Ito ay mahirap sapat na upang sumulat ng isang algorithm na habilin loop, ngunit ito ay napaka-simple, maaari mong itulak ang mga halaga envelope. Factorial ay lumalaking masyadong mabilis.

Gayunman, recursion, at mga function na tawag ng isa pang function, na maaaring gumawa ng matalinong mga callback - normal na bagay.

Halimbawa, ang isang regular na table. Ang iba pang mga talahanayan na maaaring maging isang table. Nesting hindi maaaring pinaghihigpitan. Sumulat ng para sa bawat talahanayan sarili nitong hanay ng mga tampok - masyadong maraming luxury.

Ang ganitong mga halimbawa ay marami, at ang lahat ng ito ay magiging isang tunay at pagpindot problema, hindi dahil sa programming. Iyon ay kung bakit ang problema ay namamalagi sa ang katunayan na walang-frills huwag i-set up ng isang sistema ng pag-andar, mas tiyak, ang pag-debug at kasunod maaasahang operasyon ay nagiging JavaScript pangangalaga, at Developer.