Rukia Taarifa na Ushughulikiaji Isipokuwa
Aina nyingine ya waendeshaji JavaScript ni waendeshaji wa kuruka. Kama jina linavyopendekeza, waendeshaji hawa husababisha mkalimani wa JavaScript kuruka hadi eneo lingine katika msimbo wa programu. Kauli ya mapumziko husababisha mkalimani kuruka hadi mwisho wa kitanzi au taarifa nyingine. Kauli ya kuendelea husababisha mkalimani kuruka sehemu nyingine ya kitanzi, kuruka nyuma hadi mwanzo wa kitanzi, na kuanza kutekeleza marudio mapya. JavaScript ina uwezo wa kuweka taarifa lebo kwa majina, kwa hivyo vunja na uendelee taarifa zinaweza kuonyesha kwa uwazi ni kitanzi gani au taarifa nyingine zinazomilikiwa.
Kauli ya kurudisha husababisha mkalimani kuruka kutoka kwa chaguo la kukokotoa lililoitwa hadi mahali ilipoitwa na kurudisha thamani ya simu. Taarifa ya kurusha inaleta ubaguzi na imeundwa kufanya kazi pamoja na taarifa za kujaribu/kamata/mwishowe, ambazo hufafanua kizuizi cha msimbo kushughulikia ubaguzi. Hii ni aina changamano ya opereta wa kuruka: ubaguzi unapotokea, mkalimani huruka hadi kwa kidhibiti cha vighairi kilicho karibu zaidi, ambacho kinaweza kuwa katika utendaji sawa au juu zaidi katika mrundikano wa kurejesha wa chaguo la kukokotoa linaloitwa.
Waendeshaji hawa wote wa kuruka wameelezewa kwa undani zaidi katika vifungu vifuatavyo.
Alama za maagizoMaagizo yoyote yanaweza kutiwa alama na kitambulisho na koloni:
ID: maelekezo
Kwa kuashiria maagizo, unaipa jina, ambalo linaweza kutumika kama marejeleo popote kwenye programu. Unaweza kuweka alama kwenye maagizo yoyote, lakini inaeleweka tu kuweka alama kwenye maagizo ambayo yana mwili, kama vile vitanzi na taarifa za masharti.
Kwa kukabidhi jina kwa kitanzi, basi linaweza kutumika katika taarifa za kuvunja na kuendelea, ndani ya kitanzi ili kutoka humo, au kuruka hadi mwanzo wa kitanzi hadi marudio yanayofuata. Taarifa za kuvunja na kuendelea ndizo taarifa pekee za JavaScript zinazoweza kujumuisha lebo—tutazishughulikia kwa undani zaidi baadaye. Ufuatao ni mfano wa taarifa ya muda iliyo na lebo na taarifa ya kuendelea kwa kutumia lebo hiyo:
Kitanzi kikuu: wakati (ishara != null) ( // Msimbo wa programu umeachwa... endelea kitanzi kikuu; // Sogeza hadi marudio yanayofuata ya kitanzi kilichotajwa)
Kitambulishi kinachotumika kama lebo ya taarifa kinaweza kuwa kitambulisho chochote halali cha JavaScript isipokuwa neno lililohifadhiwa. Majina ya lebo yanatenganishwa kutoka kwa majina ya kutofautisha na chaguo za kukokotoa, kwa hivyo vitambulishi vinavyolingana na tofauti au majina ya kazi vinaweza kutumika kama lebo.
Lebo za maagizo hufafanuliwa tu ndani ya maagizo ambayo yanatumika (na, bila shaka, ndani ya maagizo yaliyowekwa ndani yao). Taarifa zilizoorodheshwa haziwezi kutambulishwa kwa vitambulishi sawa na vilivyo na taarifa zao, lakini taarifa mbili huru zinaweza kutambulishwa kwa lebo sawa. Maagizo yaliyoalamishwa yanaweza kualamishwa tena. Hiyo ni, maagizo yoyote yanaweza kuwa na lebo nyingi.
taarifa ya kuvunjaTaarifa ya mapumziko husababisha kitanzi cha ndani au taarifa ya kubadili kutoka mara moja. Hapo awali tumeona mifano ya kutumia taarifa ya mapumziko ndani ya taarifa ya kubadili. Katika vitanzi, kwa kawaida hutumiwa kutoka kwenye kitanzi mara moja wakati kitanzi kinahitaji kusitishwa kwa sababu fulani.
Wakati kitanzi kina masharti magumu sana ya kusitisha, mara nyingi ni rahisi kutekeleza masharti hayo kwa kutumia taarifa ya mapumziko kuliko kujaribu kuyaeleza kwa kitanzi kimoja cha masharti. Mfano ufuatao unajaribu kupata kipengee cha safu kilicho na thamani maalum. Kitanzi huisha kwa kawaida kinapofika mwisho wa safu, au kwa taarifa ya mapumziko mara tu thamani inayotafutwa inapatikana:
Var arr = ["a","b","c","d","d"], matokeo; kwa (var i = 0; i
Katika JavaScript, unaweza kutaja jina la lebo baada ya neno kuu la mapumziko (kitambulisho bila koloni):
vunja lebo_jina;
Taarifa ya mapumziko inapotumiwa na lebo, inaruka hadi mwisho wa taarifa iliyotajwa au inakatisha utekelezaji wake. Ikiwa hakuna taarifa iliyo na lebo iliyobainishwa, kujaribu kutumia fomu hii ya taarifa ya mapumziko huzalisha hitilafu ya sintaksia. Taarifa iliyotajwa si lazima iwe kitanzi au badili taarifa. Taarifa ya mapumziko yenye lebo inaweza kutoka kwa taarifa yoyote iliyo na taarifa. Maagizo ya kanga yanaweza hata kuwa safu rahisi ya maagizo iliyoambatanishwa katika viunga vilivyojipinda kwa madhumuni ya kuiwekea lebo.
Huwezi kuingiza herufi mpya kati ya neno kuu la kuvunja na jina la lebo. Hii ni kwa sababu mkalimani wa JavaScript huingiza kiotomati semicoloni zinazokosekana: ukigawanya mstari wa msimbo kati ya neno kuu la kuvunja na lebo ifuatayo, mkalimani atadhani kuwa ulimaanisha aina rahisi ya taarifa bila lebo, na ataongeza semicolon.
Taarifa ya mapumziko iliyo na lebo inahitajika tu unapotaka kukatiza utekelezaji wa taarifa ambayo si taarifa ya kitanzi iliyo karibu zaidi au kubadili.
Endelea mwendeshajiKauli ya kuendelea ni sawa na taarifa ya mapumziko. Walakini, badala ya kutoka kwa kitanzi, taarifa ya kuendelea huanza urudiaji mpya wa kitanzi. Sintaksia ya taarifa ya kuendelea ni rahisi kama sintaksia ya taarifa ya mapumziko. Taarifa ya kuendelea pia inaweza kutumika pamoja na lebo.
Taarifa ya kuendelea, katika fomu isiyo na lebo na kwa lebo, inaweza kutumika tu katika mwili wa kitanzi. Kuitumia popote pengine husababisha hitilafu ya kisintaksia. Wakati taarifa ya kuendelea inatekelezwa, iteration ya sasa ya kitanzi inaingiliwa na inayofuata huanza. Hii inamaanisha vitu tofauti kwa aina tofauti za vitanzi:
Katika kitanzi cha muda, usemi ulioainishwa mwanzoni mwa kitanzi huangaliwa tena, na ikiwa ni kweli, mwili wa kitanzi unatekelezwa tangu mwanzo.
Kitanzi cha kufanya/wakati kinaruka hadi mwisho wa kitanzi, ambapo hali inaangaliwa tena kabla ya kutekeleza kitanzi tena.
Kitanzi cha for loop hutathmini usemi wa ongezeko na kutathmini usemi wa jaribio tena ili kubaini kama marudio yanayofuata yanafaa kufanywa.
Katika kitanzi cha/katika, kitanzi huanza tena kwa kugawa kigezo maalum kwa jina la mali inayofuata.
Kumbuka tofauti za tabia ya taarifa ya kuendelea kwa wakati na kwa vitanzi. Kitanzi cha muda kinarudi moja kwa moja kwenye hali yake, huku a for loop kwanza hutathmini usemi wa nyongeza na kisha kurudi kwenye hali. Mfano ufuatao unaonyesha utumiaji wa taarifa ya kuendelea bila lebo ili kuondoka kwenye urudiaji wa kitanzi cha sasa kwa nambari hata:
Var jumla = 0; // Kokotoa jumla ya nambari zisizo za kawaida kutoka 0 - 10 kwa (var i = 0; i
Kauli ya kuendelea, kama vile mapumziko, inaweza kutumika katika vitanzi vilivyowekwa kiota katika umbo linalojumuisha lebo, kisha kitanzi ambacho kimewashwa tena si lazima kiwe kitanzi ambacho kina taarifa ya kuendelea moja kwa moja. Zaidi ya hayo, kama ilivyo kwa mapumziko, mapumziko ya mstari hayaruhusiwi kati ya neno kuu la kuendelea na jina la lebo.
taarifa ya kurudiSimu ya kukokotoa ni usemi na, kama misemo yote, ina thamani. Taarifa ya kurejesha ndani ya chaguo za kukokotoa hutumika kubainisha thamani inayorejeshwa na chaguo la kukokotoa. Taarifa ya kurudisha inaweza tu kuonekana katika muundo wa chaguo za kukokotoa. Uwepo wake katika sehemu nyingine yoyote ni kosa la sintaksia. Taarifa ya kurejesha inapotekelezwa, chaguo la kukokotoa hurejesha thamani ya usemi kwenye programu ya kupiga simu. Kwa mfano:
Ikiwa kipengele cha kukokotoa hakina taarifa ya kurudisha, inapoitwa, mkalimani atafanya taarifa katika chombo cha kukokotoa moja baada ya nyingine hadi kufikia mwisho wa chaguo la kukokotoa, na kisha kurudisha udhibiti kwenye programu iliyoiita. Katika kesi hii, usemi wa kupiga simu utarudi bila kufafanuliwa. Taarifa ya kurejesha mara nyingi ni taarifa ya mwisho katika chaguo la kukokotoa, lakini ni ya hiari kabisa: chaguo la kukokotoa litarejesha udhibiti kwenye programu ya kupiga simu mara tu taarifa ya kurejesha inapofikiwa, hata ikiwa inafuatwa na taarifa nyingine katika chombo cha kukokotoa.
Taarifa ya kurudisha pia inaweza kutumika bila usemi, katika hali ambayo inaondoa tu chaguo la kukokotoa na kurudisha bila kufafanuliwa kwa programu ya kupiga simu. Kwa mfano:
Kazi myFun(arr) ( // Ikiwa safu ina nambari hasi, acha kitendakazi cha (var i = 0; i
kutupa kauliIsipokuwa ni ishara inayoonyesha kuwa aina fulani ya hali ya kipekee au hitilafu imetokea. Kutupa ubaguzi ni njia ya kuashiria hitilafu kama hiyo au ubaguzi. Kukamata ubaguzi kunamaanisha kusindika, i.e. kuchukua hatua zinazohitajika au zinazofaa ili kurejesha hali hiyo.
Katika JavaScript, vighairi hutupwa wakati hitilafu ya wakati wa kukimbia inapotokea na programu inapoiinua kwa uwazi kwa kutumia taarifa ya kutupa. Vighairi hunaswa kwa kutumia taarifa za kujaribu/kamata/mwisho, ambazo zimeelezwa baadaye.
Taarifa ya kutupa ina syntax ifuatayo:
kutupa kujieleza;
Matokeo ya usemi yanaweza kuwa thamani ya aina yoyote. Taarifa ya kutupa inaweza kupitishwa nambari inayowakilisha msimbo wa hitilafu au kamba iliyo na maandishi ya ujumbe wa hitilafu. Mkalimani wa JavaScript hutupa tofauti kwa kutumia mfano wa darasa la Kosa la mojawapo ya vijasusi vyake, na unaweza kutumia mbinu sawa. Kipengee cha Hitilafu kina sifa jina, ambayo inafafanua aina ya kosa, na mali ujumbe, iliyo na kamba iliyopitishwa kwa kazi ya mjenzi. Ufuatao ni mfano wa chaguo za kukokotoa ambazo huinua kitu cha Hitilafu kinapoitwa kwa hoja batili:
// Kitendakazi cha kitendakazi cha nambari (nambari) ( // Ikiwa hoja ya ingizo si thamani halali, // ubaguzi hutupwa! ikiwa (nambari 1; i *= nambari, nambari--); /* mwili wa kitanzi tupu */ return i ; ) console.log("5! = ", factorial(5)); console.log("-3! = ", factorial(-3));
Kighairi kinapotolewa, mkalimani wa JavaScript hukatiza mara moja utekelezaji wa kawaida wa programu na kuruka hadi kwa kidhibiti cha kipekee cha karibu. Vidhibiti vya ubaguzi hutumia kifungu cha kujaribu/kamata/mwishowe, ambacho kimefafanuliwa katika sehemu inayofuata.
Ikiwa kizuizi cha msimbo ambacho ubaguzi ulifanyika hauna muundo wa kukamata unaolingana, mkalimani huchunguza kizuizi cha msimbo cha nje kinachofuata na kuangalia ikiwa kidhibiti cha ubaguzi kinahusishwa nacho. Hii inaendelea hadi kidhibiti kinapatikana.
Ikiwa ubaguzi utatupwa katika chaguo la kukokotoa ambalo halina jaribio/kamata/kuunda hatimaye ili kulishughulikia, ubaguzi huo hueneza hadi msimbo ulioita chaguo hili la kukokotoa. Kwa njia hii, vighairi huenezwa kupitia muundo wa kileksika wa mbinu za JavaScript hadi safu ya simu. Ikiwa kidhibiti cha ubaguzi hakipatikani kamwe, ubaguzi huchukuliwa kama kosa na kuripotiwa kwa mtumiaji.
jaribu/kamata/hatimaye jengaJaribio/kamata/mwishowe kuunda hutekeleza utaratibu wa ushughulikiaji wa ubaguzi katika JavaScript. Taarifa ya jaribu katika muundo huu inafafanua tu kizuizi cha nambari ambayo isipokuwa hushughulikiwa. Kizuizi cha kujaribu kinafuatwa na taarifa ya kukamata iliyo na safu ya taarifa ambazo huitwa ikiwa ubaguzi utatokea mahali popote kwenye safu ya majaribio. Taarifa ya kukamata inafuatwa na kizuizi cha mwisho, ambacho kina nambari ya mwisho ambayo imehakikishwa kufanya kazi bila kujali kinachotokea kwenye kizuizi cha kujaribu.
Kizuizi cha kukamata na cha mwisho ni cha hiari, lakini angalau moja kati yao lazima kiwepo baada ya kizuizi cha kujaribu. Jaribu, kamata, na hatimaye vizuizi vinaanza na kuishia kwa viunga vilivyopindapinda. Hii ni sehemu inayohitajika ya sintaksia na haiwezi kuachwa, hata kama kuna maagizo moja tu kati yao.
Kijisehemu kifuatacho kinaonyesha sintaksia na madhumuni ya kujaribu/kamata/kuunda hatimaye:
Jaribu ( // Nambari hii kawaida huendesha vizuri kutoka mwanzo hadi mwisho. // Lakini wakati fulani inaweza kutupa ubaguzi // ama moja kwa moja kwa kutumia taarifa ya kurusha, au kwa njia isiyo ya moja kwa moja // kwa kuita njia ambayo hutoa ubaguzi. ) catch ( ex) ( // Taarifa katika uzuiaji huu zitatekelezwa ikiwa na tu ikiwa ubaguzi // utatokea kwenye kisanduku cha kujaribu. Taarifa hizi zinaweza kutumia kigezo cha kienyeji cha zamani, ambacho // kinarejelea kitu cha Hitilafu au thamani nyingine iliyobainishwa kwenye kurusha. taarifa. // Kizuizi hiki kinaweza kushughulikia ubaguzi kwa njia fulani, // kupuuza wakati wa kufanya kitu kingine, au kutupa tena ubaguzi // kwa kutumia taarifa ya kutupa. ) hatimaye ( // Kizuizi hiki kina taarifa ambazo hutekelezwa kila wakati. , bila kujali , // nini kilifanyika kwenye kizuizi cha kujaribu Wanatekelezwa ikiwa kizuizi cha majaribio kimekamilika: // 1) kama kawaida, baada ya kufikia mwisho wa kizuizi // 2) kwa sababu ya mapumziko, endelea au urudishe taarifa / / 3) isipokuwa ile inayoshughulikiwa na ile iliyo kwenye kizuizi cha samaki hapo juu // 4) na ubaguzi ambao haujashughulikiwa ambao unaendelea kueneza // kwa viwango vya juu)
Kumbuka kuwa neno kuu la kukamata linafuatwa na kitambulisho kwenye mabano. Kitambulisho hiki ni sawa na kigezo cha utendakazi. Wakati ubaguzi unanaswa, kigezo hiki kitatolewa kwa ubaguzi (kwa mfano, kitu cha Hitilafu). Tofauti na kutofautiana kwa kawaida, kitambulisho kinachohusishwa na taarifa ya kukamata kipo tu kwenye mwili wa kizuizi cha kukamata.
Ufuatao ni mfano wa kweli zaidi wa jaribio/kamata ujenzi. Inaita njia ya factorial() iliyofafanuliwa katika mfano uliopita na mteja JavaScript prompt() na alert() mbinu za kupanga ingizo na pato:
Jaribu ( // Mjulishe mtumiaji kwa nambari var n = Number(prompt("Ingiza nambari chanya", "")); // Kokotoa nambari ya nambari, ukichukulia // kwamba ingizo ni sahihi var f = factorial (n) kuhusu kosa)
Ikiwa mtumiaji ataingiza nambari hasi, ujumbe wa onyo unaonekana:
Huu ni mfano wa jaribio/kamata ujenzi bila kifungu cha mwisho. Ingawa hatimaye haitumiwi mara nyingi kama kukamata, bado ni muhimu wakati mwingine. Uzuiaji wa mwisho umehakikishiwa kutekelezwa ikiwa angalau sehemu fulani ya kizuizi cha majaribio imetekelezwa, bila kujali jinsi msimbo kwenye kizuizi cha jaribio umekamilika. Kipengele hiki kwa kawaida hutumiwa kufanya shughuli za mwisho baada ya kutekeleza msimbo katika muendelezo wa kujaribu.
Katika hali ya kawaida, udhibiti hufikia mwisho wa kizuizi cha kujaribu na kisha huhamia kwenye kizuizi cha mwisho, ambacho hufanya shughuli muhimu za mwisho. Udhibiti ukitoka kwenye kizuizi cha kujaribu kwa sababu ya taarifa ya kurejesha, kuendelea, au kuvunja, kizuizi cha mwisho kinatekelezwa kabla udhibiti kuhamishiwa mahali pengine.
Ikiwa ubaguzi utatokea kwenye kizuizi cha kujaribu na kuna kizuizi kinacholingana cha kukishughulikia, udhibiti hupita kwanza kwenye kizuizi cha kukamata na kisha mwishowe. Ikiwa hakuna kizuizi cha karibu cha kukamata, udhibiti kwanza hupita hadi kwenye kizuizi cha mwisho kisha husogea hadi kwenye kizuizi cha nje cha karibu ambacho kinaweza kushughulikia ubaguzi.
Ikiwa kizuizi chenyewe hatimaye kitahamisha udhibiti kwa kutumia taarifa ya kurejesha, kuendelea, kuvunja au kutupa au kwa kupiga simu kwa njia ambayo husababisha ubaguzi, amri inayosubiri ya uhamishaji itaghairiwa na mpya kutekelezwa. Kwa mfano, ikiwa kizuizi hatimaye kitafanya ubaguzi, ubaguzi huo utachukua nafasi ya ubaguzi wowote uliotupwa hapo awali.
Watu wanafikiri kwamba sayansi ya kompyuta ni sanaa ya fikra. Kwa kweli, ni kinyume chake - watu wengi tu wanatengeneza vitu ambavyo vinasimama juu ya kila mmoja, kana kwamba wanatengeneza ukuta wa kokoto ndogo.
Donald Knuth
Tayari umeona simu za kukokotoa kama vile arifa. Kazi ni mkate na siagi ya programu ya JavaScript. Wazo la kufunga kipande cha programu na kuiita kama tofauti ni maarufu sana. Ni zana ya kuunda programu kubwa, kupunguza marudio, kutaja subroutines, na kutenganisha subroutines kutoka kwa kila mmoja.
Matumizi dhahiri zaidi ya vitendakazi ni kuunda kamusi mpya. Kubuni maneno kwa nathari ya kawaida ya mwanadamu ni fomu mbaya. Hii ni muhimu katika lugha ya programu.
Mzungumzaji wa kawaida wa Kirusi anajua takriban maneno 10,000. Lugha adimu ya programu ina amri 10,000 zilizojengewa ndani. Na msamiati wa lugha ya programu hufafanuliwa wazi zaidi, kwa hivyo ni rahisi kubadilika kuliko mwanadamu. Kwa hiyo, kwa kawaida tunapaswa kuongeza maneno yetu wenyewe ili kuepuka kurudia-rudia kusikohitajika.
Ufafanuzi wa Kitendo Ufafanuzi wa chaguo za kukokotoa ni ufafanuzi wa kawaida wa kutofautisha, ambapo thamani ambayo kigezo hupokea ni chaguo za kukokotoa. Kwa mfano, msimbo ufuatao unafafanua mraba unaobadilika, ambao unarejelea chaguo za kukokotoa zinazokokotoa mraba wa nambari fulani:Var square = kazi(x) ( kurudi x * x; ); console.log(mraba(12)); // → 144
Chaguo za kukokotoa huundwa na usemi unaoanza na neno kuu la chaguo la kukokotoa. Kazi zina seti ya vigezo (katika kesi hii, x tu), na mwili unao na maagizo ambayo lazima yatekelezwe wakati kazi inaitwa. Mwili wa chaguo za kukokotoa huwa umefungwa katika viunga vilivyopindapinda, hata ikiwa ni pamoja na taarifa moja.
Chaguo la kukokotoa linaweza kuwa na vigezo kadhaa au lisiwe kabisa. Katika mfano ufuatao, makeNoise haina orodha ya vigezo, lakini nguvu ina mbili:
Var makeNoise = function() ( console.log("Shit!"); ); makeNoise(); // → Khrya! var power = kazi(msingi, kielelezo) ( var tokeo = 1; kwa (var count = 0; hesabu< exponent; count++) result *= base; return result; }; console.log(power(2, 10)); // → 1024
Baadhi ya chaguo za kukokotoa hurejesha thamani, kama vile nguvu na mraba, nyingine hazirudishi, kama vile makeNoise, ambayo hutoa tu athari ya upande. Taarifa ya kurejesha inabainisha thamani iliyorejeshwa na chaguo la kukokotoa. Wakati usindikaji wa programu unafikia maagizo haya, hutoka mara moja kwenye kazi na kurejesha thamani hii mahali katika msimbo ambao kazi iliitwa. return bila usemi inarudi undefined .
Vigezo na upeo Vigezo vya kazi ni vigezo sawa, lakini maadili yao ya awali yanawekwa wakati kazi inaitwa, na si katika kanuni yake.Sifa muhimu ya chaguo za kukokotoa ni kwamba vigeuzo vilivyoundwa ndani ya chaguo za kukokotoa (pamoja na vigezo) ni vya ndani kwa kazi hiyo. Hii inamaanisha kuwa katika mfano wa nguvu, utofauti wa matokeo utaundwa kila wakati chaguo la kukokotoa linapoitwa, na miili hii ya kibinafsi haitakuwa na uhusiano wowote na kila mmoja.
Eneo hili la kutofautisha linatumika tu kwa vigezo na vigeuzo vilivyoundwa ndani ya vitendakazi. Vigezo vilivyofafanuliwa nje ya chaguo za kukokotoa huitwa kimataifa kwa sababu vinaonekana kote kwenye programu. Unaweza pia kupata vigeuzo kama hivi ndani ya chaguo za kukokotoa, isipokuwa utangaze kitofauti cha ndani kilicho na jina moja.
Nambari ifuatayo inaonyesha hii. Inafafanua na kuita vitendaji viwili ambavyo vinapeana thamani kwa kutofautisha x. Ya kwanza inaitangaza kama ya kawaida, na hivyo kubadilisha tu utofauti wa kawaida. Ya pili haitangazi, kwa hivyo kufanya kazi na x ndani ya chaguo la kukokotoa inarejelea utofauti wa kimataifa uliofafanuliwa mwanzoni mwa mfano.
Var x = "nje"; var f1 = kazi() ( var x = "ndani ya f1"; ); f1(); console.log(x); // → nje var f2 = kazi() ( x = "ndani ya f2"; ); f2(); console.log(x); // → ndani ya f2
Tabia hii husaidia kuzuia mwingiliano wa bahati mbaya kati ya vitendaji. Ikiwa vigezo vyote vilitumiwa mahali popote kwenye programu, itakuwa vigumu sana kuhakikisha kuwa tofauti moja haikutumiwa kwa madhumuni tofauti. Na ikiwa ungetumia tena kibadilishaji, ungekumbana na athari za kushangaza wakati nambari ya mtu wa tatu inapotosha maadili ya utofauti wako. Kwa kutibu vigeu vya kitendakazi-eneo ili viwepo tu ndani ya chaguo za kukokotoa, lugha huwezesha kufanya kazi na vitendakazi kana kwamba ni ulimwengu mdogo tofauti, huku kuruhusu usiwe na wasiwasi kuhusu msimbo mzima.
JavaScript ya upeo wa nested hutofautisha zaidi ya vigeuzo vya kimataifa na vya ndani. Kazi zinaweza kubainishwa ndani ya vitendakazi, na kusababisha viwango vingi vya eneo.Kwa mfano, kazi ifuatayo isiyo na maana ina mbili zaidi ndani:
Var landscape = function() ( var result = ""; var flat = kazi(saizi) ( kwa (var count = 0; count< size; count++) result += "_"; }; var mountain = function(size) { result += "/"; for (var count = 0; count < size; count++) result += """; result += "\\"; }; flat(3); mountain(4); flat(6); mountain(1); flat(1); return result; }; console.log(landscape()); // → ___/""""\______/"\_
Kazi za gorofa na za mlima huona mabadiliko ya matokeo kwa sababu ziko ndani ya chaguo la kukokotoa linaloifafanua. Lakini hawawezi kuona vigezo vya hesabu vya kila mmoja kwa sababu vigeu vya kazi moja viko nje ya upeo wa nyingine. Na mazingira nje ya kipengele cha kukokotoa mazingira hayaoni vigeuzo vyovyote vilivyofafanuliwa ndani ya chaguo la kukokotoa.
Kwa kifupi, ndani ya kila wigo wa ndani, unaweza kuona mawanda yote yaliyo nayo. Seti ya vigezo vinavyopatikana ndani ya chaguo za kukokotoa imedhamiriwa na mahali ambapo kazi inatangazwa katika programu. Vigezo vyote kutoka kwa vitalu vinavyozunguka ufafanuzi wa kazi vinaonekana - ikiwa ni pamoja na wale waliofafanuliwa katika ngazi ya juu katika programu kuu. Mbinu hii ya mawanda inaitwa lexical.
Watu ambao wamesoma lugha zingine za programu wanaweza kufikiria kuwa kizuizi chochote kilichofungwa kwenye brashi za curly huunda mazingira yake ya ndani. Lakini katika JavaScript, kazi pekee huunda wigo. Unaweza kutumia vitalu vya kusimama huru:
Var kitu = 1; ( var something = 2; // Fanya kitu na kitu tofauti... ) // Umetoka kwenye kizuizi...
Lakini kitu ndani ya block ni tofauti sawa na nje. Ingawa vizuizi kama hivyo vinaruhusiwa, inafanya akili kuzitumia ikiwa kauli na vitanzi.
Ikiwa hii inaonekana kuwa ya kushangaza kwako, sio wewe tu unayefikiria hivyo. JavaScript 1.7 ilianzisha neno kuu la let, ambalo hufanya kazi kama var lakini huunda vigeuzo ambavyo ni vya kawaida kwa kizuizi chochote, sio kazi tu.
Kazi kama Majina ya Kazi ya Maadili kawaida hutumiwa kama jina la kipande cha programu. Tofauti kama hiyo imewekwa mara moja na haibadilika. Kwa hivyo ni rahisi kuchanganya kazi na jina lake.Lakini haya ni mambo mawili tofauti. Simu ya kukokotoa inaweza kutumika kama kigezo rahisi - kwa mfano, kutumika katika usemi wowote. Inawezekana kuhifadhi simu ya kazi katika kibadilishaji kipya, kuipitisha kama parameta kwa kazi nyingine, na kadhalika. Pia, tofauti inayohifadhi simu ya kukokotoa inabaki kuwa tofauti ya kawaida na thamani yake inaweza kubadilishwa:
Var launchMissiles = function(thamani) ( missileSystem.launch("au!"); ); ikiwa (Mode salama) launchMissiles = function(thamani) (/* kufuta */);
Katika Sura ya 5, tutajadili mambo mazuri unayoweza kufanya kwa kupitisha simu za kukokotoa kwa vipengele vingine.
Kutangaza Kazi Kuna toleo fupi la usemi "var square = kazi ...". Neno kuu la kazi linaweza kutumika mwanzoni mwa taarifa:Alama ya mraba(x) ( rudisha x * x; )
Hili ni tangazo la utendaji. Taarifa inafafanua kigezo cha mraba na kukipa kitendakazi kilichopewa. Hadi sasa nzuri sana. Kuna shida moja tu katika ufafanuzi kama huo.
Console.log("Yajayo yanasema:", future()); function future() ( rudi "BADO hatuna magari ya kuruka."; )
Nambari hii inafanya kazi ingawa chaguo la kukokotoa limetangazwa chini ya msimbo unaoitumia. Hii ni kwa sababu matamko ya utendakazi si sehemu ya utekelezaji wa kawaida wa programu kutoka juu chini. "Zimehamishwa" juu ya upeo wao na zinaweza kuitwa na msimbo wowote katika upeo huo. Wakati mwingine hii ni rahisi kwa sababu unaweza kuandika msimbo kwa mpangilio unaoeleweka zaidi bila kuwa na wasiwasi juu ya kufafanua kazi zote hapo juu zinapotumika.
Ni nini hufanyika ikiwa tutaweka tangazo la utendaji ndani ya kizuizi cha masharti au kitanzi? Huna budi kufanya hivyo. Kihistoria, majukwaa tofauti yanayoendesha JavaScript yameshughulikia kesi kama hizi kwa njia tofauti, na kiwango cha sasa cha lugha kinakataza hili. Ikiwa unataka programu zako ziendeshe kwa mfuatano, tumia matamko ya utendakazi ndani ya vitendakazi vingine au programu kuu pekee.
Mfano wa kazi() ( kazi a() () // Kawaida ikiwa (kitu) ( kazi b() () // Ay-yay-yay! ) )
Wito Stack Inasaidia kuangalia kwa karibu jinsi agizo la utekelezaji linavyofanya kazi na vitendaji. Hapa kuna programu rahisi na simu chache za kazi:Kazi ya salamu(nani) ( console.log("Hujambo, " + nani); ) salamu("Semyon"); console.log("Pokeda");
Inachakatwa kama hii: salamu ya kupiga simu husababisha pasi kuruka hadi mwanzo wa chaguo la kukokotoa. Inaita kazi ya console.log iliyojengwa, ambayo inaingilia udhibiti, hufanya mambo yake, na inarudi udhibiti. Kisha anafika mwisho wa salamu, na kurudi mahali alipoitwa kutoka. Mstari unaofuata unaita console.log tena.
Hii inaweza kuonyeshwa kimkakati kama hii:
Juu salimia console.log salimia top console.log top
Kwa sababu kazi lazima irudi mahali ilipoitwa, kompyuta lazima ikumbuke muktadha ambao kazi hiyo iliitwa. Katika hali moja, console.log inapaswa kurudi ili kusalimiana. Katika lingine, anarudi hadi mwisho wa programu.
Mahali ambapo kompyuta inakumbuka muktadha huitwa stack. Kila mara kipengele cha kukokotoa kinapoitwa, muktadha wa sasa unasukumwa hadi juu ya rafu. Chaguo za kukokotoa zinaporudi, hutokeza muktadha wa juu kutoka kwenye rafu na kuutumia kuendelea kufanya kazi.
Hifadhi ya rafu inahitaji nafasi ya kumbukumbu. Rafu inapokuwa kubwa sana, kompyuta itaacha kutekeleza na kusema kitu kama "furika ya rafu" au "kurudisha sana." Nambari ifuatayo inaonyesha hii - inauliza kompyuta swali ngumu sana, ambayo husababisha kuruka kwa ukomo kati ya kazi mbili. Kwa usahihi zaidi, itakuwa ni kuruka usio na kikomo ikiwa kompyuta ilikuwa na stack isiyo na mwisho. Kwa kweli, stack inafurika.
Kazi kuku() ( return yai(); ) kazi yai() ( return chicken(); ) console.log(chicken() + " alikuja kwanza."); // → ??
Hoja za Hiari Nambari ifuatayo ni halali kabisa na hufanya kazi bila shida:Tahadhari("Habari", "Habari za jioni", "Habari kila mtu!");
Rasmi, kazi inachukua hoja moja. Walakini, akipingwa hivi, yeye halalamiki. Anapuuza hoja zilizosalia na kuonyesha "Hujambo."
JavaScript ni mahususi sana kuhusu idadi ya hoja zinazopitishwa kwa chaguo za kukokotoa. Ikiwa utahamisha sana, zile za ziada zitapuuzwa. Wachache sana na wanaokosekana watapewa thamani ambayo haijafafanuliwa.
Upande mbaya wa mbinu hii ni kwamba inawezekana - na hata uwezekano - kupitisha idadi isiyo sahihi ya hoja kwa kazi bila mtu yeyote kuilalamikia.
Faida ni kwamba unaweza kuunda vitendaji ambavyo huchukua hoja za hiari. Kwa mfano, katika toleo linalofuata la kazi ya nguvu, inaweza kuitwa kwa hoja mbili au moja - katika kesi ya mwisho, kielelezo kitakuwa sawa na mbili, na kazi inafanya kazi kama mraba.
Nguvu ya utendaji (msingi, kipeo) (ikiwa (kielelezo == kisichobainishwa) kielelezo = 2; matokeo ya var = 1; kwa (hesabu ya var = 0; hesabu< exponent; count++) result *= base; return result; } console.log(power(4)); // → 16 console.log(power(4, 3)); // → 64
Katika sura inayofuata, tutaona jinsi unavyoweza kujua katika mwili wa chaguo za kukokotoa idadi kamili ya hoja zilizopitishwa kwake. Hii ni muhimu kwa sababu ... hukuruhusu kuunda chaguo za kukokotoa ambazo huchukua idadi yoyote ya hoja. Kwa mfano, console.log hutumia mali hii na kuchapisha hoja zote zilizopitishwa kwake:
Console.log("R", 2, "D", 2); // → R 2 D 2
Kufungwa Uwezo wa kutumia simu za kukokotoa kama vigeu, pamoja na ukweli kwamba viambajengo vya ndani vinaundwa upya kila wakati kitendakazi kinapoitwa, hutuongoza kwa swali la kuvutia. Ni nini hufanyika kwa anuwai za kawaida wakati chaguo la kukokotoa linacha kufanya kazi?Mfano ufuatao unaonyesha suala hili. Inatangaza utendakazi wa wrapValue, ambayo huunda utofauti wa ndani. Kisha hurejesha chaguo la kukokotoa ambalo husoma kigezo hiki cha ndani na kurudisha thamani yake.
Kazi wrapValue(n) ( var localVariable = n; return function() ( return localVariable; ); ) var wrap1 = wrapValue(1); var wrap2 = wrapValue(2); console.log(wrap1()); // → 1 console.log(wrap2()); // → 2
Hii ni halali na inafanya kazi kama inavyopaswa - ufikiaji wa kutofautisha unabaki. Zaidi ya hayo, matukio mengi ya kutofautiana sawa yanaweza kuwepo kwa wakati mmoja, ambayo inathibitisha zaidi ukweli kwamba vigezo vya ndani vinaundwa upya kwa kila simu ya kazi.
Uwezo huu wa kufanya kazi kwa kurejelea mfano wa utofauti wa ndani unaitwa kufungwa. Chaguo la kukokotoa ambalo hufunga vigeu vya ndani huitwa kufungwa. Sio tu inakuweka huru kutokana na wasiwasi kuhusu maisha tofauti, lakini pia hukuruhusu kutumia vitendaji kwa ubunifu.
Kwa urekebishaji kidogo, tunageuza mfano wetu kuwa chaguo la kukokotoa ambalo huzidisha nambari kwa nambari yoyote ile.
Kizidishi cha kazi (sababu) ( kazi ya kurudisha (nambari) ( nambari ya kurudisha * sababu; ) var mara mbili = kizidishi (2); console.log(mara mbili(5)); // → 10
Tofauti tofauti kama localVariable kutoka kwa mfano wa wrapValue haihitajiki tena. Kwa kuwa parameta yenyewe ni tofauti ya ndani.
Itachukua mazoezi kuanza kufikiria hivi. Mfano mzuri wa kiakili ni kufikiria kuwa kitendakazi hufungia msimbo kwenye mwili wake na kuufunga kwenye kifurushi. Unapoona return function(...) (...), ifikirie kama paneli dhibiti ya kipande cha msimbo kilichogandishwa kwa matumizi ya baadaye.
Katika mfano wetu, kizidishi kinarejesha kipande cha msimbo kilichogandishwa, ambacho tunahifadhi kwa kutofautisha mara mbili. Mstari wa mwisho huita kazi iliyomo katika kutofautiana, ambayo husababisha msimbo uliohifadhiwa kuanzishwa (nambari ya kurudi * factor;). Bado ina ufikiaji wa utofauti wa sababu ambayo ilifafanuliwa wakati wa kupiga simu kizidishi, na pia ina ufikiaji wa hoja iliyopitishwa wakati wa defrost (5) kama kigezo cha nambari.
Urudiaji Chaguo la kukokotoa linaweza kujiita mradi tu ichukue tahadhari isizidishe rundo. Kitendaji hiki kinaitwa kujirudia. Hapa kuna mfano wa utekelezaji mbadala wa ufafanuzi:Nguvu ya utendaji (msingi, kipeo) ( ikiwa (kipeo == 0) rudisha 1; vinginevyo rudisha msingi * nguvu(msingi, kipeo - 1); ) console.log(nguvu(2, 3)); // → 8
Hivi ndivyo takriban jinsi wanahisabati hufafanua ufafanuzi, na labda hii inaelezea dhana kwa uzuri zaidi kuliko mzunguko. Chaguo za kukokotoa hujiita mara nyingi kwa hoja tofauti ili kufikia kuzidisha nyingi.
Walakini, utekelezaji huu una shida - katika mazingira ya kawaida ya JavaScript ni polepole mara 10 kuliko toleo lenye kitanzi. Kutembea kwa kitanzi ni nafuu kuliko kuita kazi.
Mtanziko wa kasi dhidi ya ulimbwende unavutia sana. Kuna pengo fulani kati ya urahisi kwa wanadamu na urahisi wa mashine. Mpango wowote unaweza kuharakishwa kwa kuifanya kuwa kubwa na ngumu zaidi. Mtayarishaji programu anahitajika kupata usawa unaofaa.
Katika kesi ya ufafanuzi wa kwanza, kitanzi kisicho na usawa ni rahisi sana na moja kwa moja. Haina maana kuibadilisha na kujirudia. Mara nyingi, hata hivyo, programu zinahusika na dhana hizo ngumu ambazo mtu anataka kupunguza ufanisi kwa kuongeza usomaji.
Kanuni ya msingi, ambayo imerudiwa zaidi ya mara moja, na ambayo ninakubali kabisa, sio kuwa na wasiwasi juu ya utendaji mpaka uhakikishe kabisa kwamba programu inapungua. Ikiwa ni hivyo, tafuta sehemu zinazodumu kwa muda mrefu zaidi na ufanye biashara kwa ufanisi.
Bila shaka, hatupaswi kupuuza kabisa utendaji mara moja. Katika hali nyingi, kama ilivyo kwa ufafanuzi, hatupati urahisi kutoka kwa suluhisho za kifahari. Wakati mwingine programu mwenye ujuzi anaweza kuona mara moja kwamba mbinu rahisi haitakuwa haraka vya kutosha.
Ninaelezea hili kwa sababu watengenezaji programu wengi wa novice wanazingatia ufanisi hata katika mambo madogo. Matokeo yake ni kubwa, ngumu zaidi na mara nyingi sio bila makosa. Programu kama hizo huchukua muda mrefu kuandika, lakini mara nyingi hazifanyi kazi haraka sana.
Lakini kujirudia sio tu njia mbadala isiyofaa ya vitanzi. Baadhi ya matatizo ni rahisi kutatua kwa kujirudia. Mara nyingi hii ni mteremko wa matawi kadhaa ya mti, ambayo kila moja inaweza tawi.
Hapa kuna kitendawili: unaweza kupata idadi isiyo na kikomo ya nambari kwa kuanza na nambari 1, na kisha kuongeza 5 au kuzidisha na 3. Tunaandikaje kazi ambayo, kwa kupewa nambari, inajaribu kupata mlolongo wa nyongeza na kuzidisha? hiyo inaongoza kwa nambari fulani? Kwa mfano, nambari 13 inaweza kupatikana kwa kwanza kuzidisha 1 kwa 3 na kisha kuongeza 5 mara mbili. Na nambari 15 haiwezi kupatikana kwa njia hii hata kidogo.
Suluhisho la kujirudia:
Function findSolution(target) ( kazi find(anza, historia) (ikiwa (anza == target) rejesha historia; vinginevyo ikiwa (anza > target) return null; else return find(start + 5, "(" + history + " + 5)") || pata(anza * 3, "(" + historia + " * 3)"); ) rudisha find(1, "1"); ) console.log(findSolution(24)); // → (((1 * 3) + 5) * 3)
Mfano huu sio lazima kupata suluhisho fupi zaidi - inaridhika na yoyote. Sitarajii uelewe mara moja jinsi programu inavyofanya kazi. Lakini hebu tuelewe zoezi hili kubwa katika fikra za kujirudia.
Kitendaji cha ndani find hujirudia. Inachukua hoja mbili - nambari ya sasa na mfuatano ambao una rekodi ya jinsi tulivyofikia nambari hii. Na inarudisha kamba inayoonyesha mlolongo wetu wa hatua, au null.
Kwa kufanya hivyo, kazi hufanya moja ya vitendo vitatu. Ikiwa nambari iliyopewa ni sawa na lengo, basi hadithi ya sasa ndiyo njia ya kuifanikisha, kwa hivyo inarudi. Ikiwa nambari iliyotolewa ni kubwa kuliko lengo, hakuna maana ya kuendelea kuzidisha na kuongeza, kwa sababu itaongezeka tu. Na ikiwa bado hatujafikia lengo, chaguo la kukokotoa hujaribu njia zote mbili zinazowezekana kuanzia na nambari iliyotolewa. Anajiita mara mbili, mara moja kwa kila mbinu. Ikiwa simu ya kwanza hairudi bila malipo, inarudishwa. Katika hali nyingine, ya pili inarudishwa.
Ili kuelewa vizuri jinsi kazi inavyofikia athari inayotaka, wacha tuangalie simu inayofanya kupata suluhisho kwa nambari 13.
Tafuta(1, "1") pata(6, "(1 + 5))") pata(11, "((1 + 5) + 5)") pata(16,"((1 + 5) + 5) ) + 5)") kupata kubwa mno(33, "(((1 + 5) + 5) * 3)") kupata kubwa mno(18, "(1 + 5) * 3)") kupata kubwa mno( 3, "(1 * 3)") pata(8, "((1 * 3) + 5)") pata(13,(((1 * 3) + 5) + 5)") kupatikana!
Ujongezaji unaonyesha kina cha safu ya simu. Mara ya kwanza, kitendakazi cha kutafuta kinajiita mara mbili ili kuangalia suluhisho kuanzia na (1 + 5) na (1 * 3). Simu ya kwanza hutafuta suluhisho kuanzia na (1 + 5) na hutumia urejeshaji kuangalia suluhu zote zinazotoa nambari chini ya au sawa na nambari inayotakiwa. Haijaipata na inarudisha null. Kisha mwendeshaji || na inasonga kwa simu ya kukokotoa ambayo inachunguza chaguo la (1 * 3). Tuna bahati hapa, kwa sababu katika simu ya tatu ya kujirudia tunapata 13. Simu hii inarudisha kamba, na kila moja ya || njiani hupitisha mstari huu juu, na kusababisha kurudisha suluhisho.
Kukuza Kazi Kuna njia mbili zaidi au chini za asili za kutambulisha vitendaji kwenye programu.Ya kwanza ni kwamba unaandika nambari kama hiyo mara kadhaa. Hii inapaswa kuepukwa - nambari zaidi inamaanisha nafasi zaidi ya makosa na nyenzo zaidi za kusoma kwa wale wanaojaribu kuelewa programu. Kwa hivyo tunachukua utendakazi unaojirudia, tuupe jina zuri, na kuuweka kwenye kitendakazi.
Njia ya pili ni kwamba unagundua hitaji la utendakazi mpya ambao unastahili kuwekwa katika kitendakazi tofauti. Unaanza na jina la kazi, na kisha uandike mwili wake. Unaweza hata kuanza kwa kuandika msimbo unaotumia chaguo la kukokotoa kabla kitendakazi chenyewe hakijafafanuliwa.
Jinsi ilivyo ugumu kwako kutaja chaguo za kukokotoa huonyesha jinsi unavyoelewa utendakazi wake. Hebu tuchukue mfano. Tunahitaji kuandika programu ambayo inachapisha nambari mbili, idadi ya ng'ombe na kuku kwenye shamba, ikifuatiwa na maneno "ng'ombe" na "kuku." Unahitaji kuongeza zero kwa nambari za mbele ili kila moja ichukue nafasi tatu haswa.
007 Ng'ombe 011 Kuku
Ni wazi, tunahitaji kazi yenye hoja mbili. Wacha tuanze kuweka msimbo.
// chapisha kipengele cha kazi cha FarmInventory printFarmInventory(ng'ombe, kuku) ( var cowString = Kamba(ng'ombe); wakati (cowString.length< 3)
cowString = "0" + cowString;
console.log(cowString + " Коров");
var chickenString = String(chickens);
while (chickenString.length < 3)
chickenString = "0" + chickenString;
console.log(chickenString + " Куриц");
}
printFarmInventory(7, 11);
Ikiwa tunaongeza .length kwa kamba, tunapata urefu wake. Inabadilika kuwa wakati wa vitanzi huongeza zero zinazoongoza kwa nambari hadi wapate mstari wa herufi 3.
Tayari! Lakini tulipokuwa karibu kutuma nambari kwa mkulima (pamoja na hundi kubwa, bila shaka), anapiga simu na kutuambia kwamba ana nguruwe kwenye shamba lake, na tunaweza kuongeza onyesho la idadi ya nguruwe kwenye shamba. programu?
Bila shaka inawezekana. Lakini tunapoanza kunakili na kubandika msimbo kutoka kwa mistari hii minne, tunagundua kuwa tunahitaji kusimama na kufikiria. Lazima kuwe na njia bora zaidi. Tunajaribu kuboresha programu:
// pato KWA Kuongeza Sifuri NA vitendakazi vya Lebo printZeroPaddedWithLabel(nambari, lebo) ( var numberString = Kamba(nambari); huku (numberString.length< 3) numberString = "0" + numberString; console.log(numberString + " " + label); } // вывестиИнвентаризациюФермы function printFarmInventory(cows, chickens, pigs) { printZeroPaddedWithLabel(cows, "Коров"); printZeroPaddedWithLabel(chickens, "Куриц"); printZeroPaddedWithLabel(pigs, "Свиней"); } printFarmInventory(7, 11, 3);
Inafanya kazi! Lakini jina printZeroPaddedWithLabel ni la kushangaza kidogo. Inachanganya vitu vitatu - pato, kuongeza sufuri, na lebo - kuwa chaguo moja la kukokotoa. Badala ya kuingiza kipande kizima kinachojirudia kwenye kazi, wacha tuangazie wazo moja:
// ongeza kitendakazi cha Sifuri zeroPad(nambari, upana) ( var string = Kamba(nambari); huku (string.length< width) string = "0" + string; return string; } // вывестиИнвентаризациюФермы function printFarmInventory(cows, chickens, pigs) { console.log(zeroPad(cows, 3) + " Коров"); console.log(zeroPad(chickens, 3) + " Куриц"); console.log(zeroPad(pigs, 3) + " Свиней"); } printFarmInventory(7, 16, 3);
Chaguo za kukokotoa zilizo na jina zuri na wazi zeroPad hurahisisha msimbo kueleweka. Na inaweza kutumika katika hali nyingi, si tu katika kesi yetu. Kwa mfano, kuonyesha meza zilizoumbizwa na nambari.
Je, vipengele vinapaswa kuwa mahiri na vingi kiasi gani? Tunaweza kuandika chaguo rahisi la kukokotoa ambalo huweka nambari kwa sufuri hadi nafasi tatu, au chaguo la kukokotoa la jumla la kisasa la uumbizaji wa nambari zinazoauni sehemu, nambari hasi, upangaji wa nukta, pedi, n.k.
Sheria nzuri ya kidole gumba ni kuongeza utendaji tu ambao unajua kuwa utakuwa muhimu. Wakati mwingine inajaribu kuunda mifumo ya madhumuni ya jumla kwa kila hitaji dogo. mpingeni. Hutawahi kumaliza kazi, utaishia tu kuandika rundo la nambari ambazo hakuna mtu atakayetumia.
Kazi na Madhara Matendo yanaweza kugawanywa takriban katika yale yanayoitwa kwa madhara yake na yale yanayoitwa kupata thamani fulani. Bila shaka, inawezekana pia kuchanganya mali hizi katika kazi moja.Kazi ya msaidizi wa kwanza katika mfano wa shamba, printZeroPaddedWithLabel, inaitwa kwa sababu ina athari ya upande: inachapisha kamba. Ya pili, zeroPad, kwa sababu ya thamani ya kurudi. Na sio bahati mbaya kwamba kazi ya pili inakuja mara nyingi zaidi kuliko ya kwanza. Kazi zinazorudisha maadili ni rahisi kuchanganya na kila mmoja kuliko vitendakazi ambavyo hutoa athari.
Chaguo la kukokotoa safi ni aina maalum ya utendakazi wa kurejesha thamani ambayo sio tu kwamba haina madhara, lakini pia haitegemei madhara ya msimbo mwingine - kwa mfano, haifanyi kazi na vigeu vya kimataifa ambavyo vinaweza kuwa kwa bahati mbaya. imebadilishwa mahali pengine. Kazi safi, inapoitwa kwa hoja sawa, inarudisha matokeo sawa (na haifanyi chochote) - ambayo ni nzuri kabisa. Yeye ni rahisi kufanya kazi naye. Wito kwa kazi hiyo inaweza kubadilishwa kiakili na matokeo ya kazi yake, bila kubadilisha maana ya kanuni. Unapotaka kujaribu kazi kama hiyo, unaweza kuiita tu, na uhakikishe kuwa ikiwa inafanya kazi katika muktadha fulani, itafanya kazi katika muktadha wowote. Vitendaji visivyo safi zaidi vinaweza kurudisha matokeo tofauti kulingana na vipengele vingi, na kuwa na madhara ambayo ni vigumu kupima na kuhesabu.
Hata hivyo, hupaswi kuwa na aibu kuandika kazi ambazo si safi kabisa, au kuanza utakaso wa kanuni takatifu ya kazi hizo. Madhara mara nyingi huwa na manufaa. Hakuna njia ya kuandika toleo safi la kazi ya console.log, na kazi hii ni muhimu sana. Baadhi ya shughuli ni rahisi kueleza kwa kutumia madhara.
Muhtasari Sura hii ilikuonyesha jinsi ya kuandika vitendaji vyako mwenyewe. Wakati neno kuu la chaguo la kukokotoa linapotumika kama usemi, hurejesha kielekezi kwenye simu ya kukokotoa. Inapotumika kama maagizo, unaweza kutangaza kigezo kwa kukipa simu ya kukokotoa.Ufunguo wa kuelewa utendakazi ni upeo wa ndani. Vigezo na vigeu vilivyotangazwa ndani ya chaguo za kukokotoa ni vya ndani yake, huundwa upya kila inapoitwa, na havionekani kutoka nje. Kazi zilizotangazwa ndani ya chaguo za kukokotoa nyingine zinaweza kufikia upeo wake.
Ni muhimu sana kutenganisha kazi tofauti zinazofanywa na programu katika vitendaji. Sio lazima ujirudie; vitendaji hufanya msimbo kusomeka zaidi kwa kuigawanya katika sehemu zenye maana, kama vile sura na sehemu za kitabu husaidia kupanga maandishi ya kawaida.
MazoeziKima cha Chini Katika sura iliyotangulia, tulitaja kazi ya Math.min, ambayo inarudisha hoja ndogo kabisa kati ya hoja zake. Sasa tunaweza kuandika kazi kama hiyo sisi wenyewe. Andika kitendakazi cha min ambacho huchukua hoja mbili na kurudisha kiwango cha chini kati yao.Console.logi(dk(0, 10)); // → 0 console.log(min(0, -10)); // → -10
Recursion Tumeona kwamba % (modulo) opereta inaweza kutumika kubainisha kama idadi (%2) ni sawia. Hapa kuna njia nyingine ya kuifafanua:Zero ni sawa.
Kitengo ni isiyo ya kawaida.
Nambari yoyote N ina usawa sawa na N-2.
Andika kazi ya kujirudia niHata kulingana na sheria hizi. Ni lazima ukubali nambari na kurudisha thamani ya boolean.
Ijaribu kwa 50 na 75. Jaribu kuipa -1. Kwa nini anafanya hivi? Je, inawezekana kurekebisha kwa namna fulani?
Ijaribu kwenye 50 na 75. Tazama jinsi inavyofanya kwenye -1. Kwa nini? Unaweza kufikiria njia ya kurekebisha hii?
Console.log(isEven(50)); // → kweli console.log(isEven(75)); // → koni ya uwongo.log(isEven(-1)); // → ??
Kuhesabu maharagwe.Nambari ya herufi N ya mfuatano inaweza kupatikana kwa kuongeza .charAt(N) (“kamba”.charAt(5)) kwake - kwa njia sawa na kupata urefu wa mfuatano kwa kutumia .length. Thamani ya kurudi itakuwa mfuatano unaojumuisha herufi moja (kwa mfano, "k"). Herufi ya kwanza ya mfuatano ina nafasi ya 0, ambayo ina maana kwamba mhusika wa mwisho atakuwa na kamba ya nafasi. urefu - 1. Kwa maneno mengine, mfuatano wa wahusika wawili una urefu wa 2, na nafasi zake za tabia zitakuwa 0 na 1.
Andika hesabu za chaguo za kukokotoa ambazo huchukua mfuatano kama hoja na kurudisha idadi ya vibambo "B" vilivyomo kwenye mfuatano huo.
Kisha andika kitendakazi kinachoitwa countChar, ambacho hufanya kazi kama hesabuB, lakini huchukua kigezo cha pili - herufi ambayo tutatafuta kwenye mfuatano (badala ya kuhesabu tu idadi ya herufi "B"). Ili kufanya hivyo, rekebisha kitendakazi cha countBs.
Kazi ni mojawapo ya vizuizi muhimu vya ujenzi wa msimbo katika JavaScript.
Kazi zinajumuisha seti ya amri na kwa kawaida hufanya kazi moja maalum (kwa mfano, nambari za muhtasari, mizizi ya kuhesabu, nk).
Msimbo uliowekwa kwenye chaguo za kukokotoa utatekelezwa tu baada ya simu ya wazi kwa chaguo hili la kukokotoa.
Tamko la Kazi1. Sintaksia:
//Tamko la kazi ya kukokotoaJina la kukokotoa(ln1, ln2)( Msimbo wa kazi) //Kuita jina la kaziFunctionname(ln1,lr2);
2. Sintaksia:
//Tamko la chaguo la kukokotoa var jina=function(ln1, ln2)(Msimbo wa kazi) //Kuita jina la chaguo la kukokotoa(ln1,lr2);
functionname hubainisha jina la chaguo za kukokotoa. Kila chaguo la kukokotoa kwenye ukurasa lazima liwe na jina la kipekee. Jina la chaguo la kukokotoa lazima libainishwe kwa herufi za Kilatini na lisianze na nambari.
ln1 na ln2 ni vigezo au maadili ambayo yanaweza kupitishwa kwenye chaguo la kukokotoa. Idadi isiyo na kikomo ya vigeu inaweza kupitishwa kwa kila chaguo la kukokotoa.
Tafadhali kumbuka: hata kama hakuna vigezo vinavyopitishwa kwa chaguo za kukokotoa, usisahau kuingiza mabano "()" baada ya jina la chaguo la kukokotoa.
Tafadhali kumbuka kuwa majina ya chaguo za kukokotoa katika JavaScript ni nyeti kwa ukubwa.
Mfano kazi ya JavaScriptKitendaji cha messageWrite() katika mfano ulio hapa chini kitatekelezwa tu baada ya kubofya kitufe.
Kumbuka kuwa mfano huu unatumia tukio la kubofya. Matukio ya JavaScript yatajadiliwa kwa kina baadaye katika mafunzo haya.
// Kazi huandika maandishi kwa ujumbe wa kazi ya ukurasaWrite() ( document.write("Nakala hii iliandikwa kwa ukurasa kwa kutumia JavaScript!");)
Kupitisha Vigezo kwa KaziUnaweza kupitisha idadi isiyo na kikomo ya vigezo kwa kazi.
Tafadhali kumbuka: ghiliba zote zilizo na vigeu vya ndani vya kazi kwa kweli hazifanyiki kwa anuwai zenyewe, lakini kwa nakala zao, kwa hivyo yaliyomo kwenye vigeuzi wenyewe haibadiliki kama matokeo ya utendaji wa kazi.
/* Hebu tufafanue chaguo la kukokotoa ambalo linaongeza 10 kwa kigezo kilichopitishwa na kuonyesha matokeo kwenye ukurasa */ kazi plus(a)( a=a+10; document.write("Function output: " + a+"
"); ) var a=25; document.write("Thamani ya kigezo kabla ya simu ya kukokotoa: "+a+"
"); // Ipigie simu kitendakazi kwa kuipitisha kibadilishi a plus(a); document.write("Thamani ya kigezo baada ya kuita kitendakazi: "+a+"
");
Mtazamo wa haraka
Ili kufikia kigezo cha kimataifa kutoka kwa chaguo za kukokotoa badala ya nakala yake, tumia window.variable_name.
Kazi plus(a)( window.a=a+10; ) var a=25; document.write("Thamani ya kigezo kabla ya simu ya kukokotoa: "+a+"
"); plus(a); document.write("Thamani ya kigezo baada ya kuita chaguo za kukokotoa: "+a+"
");
Mtazamo wa haraka
amri ya kurudiKwa amri ya kurudi unaweza kurudisha maadili kutoka kwa vitendaji.
//Jumla ya kukokotoa hurejesha jumla ya vigeu vilivyopitishwa kwake sum(v1,v2)( return v1+v2; ) document.write("5+6=" + sum(5,6) + "
"); document.write("10+4=" + sum(10,4) + "
");
Mtazamo wa haraka
Vitendaji vilivyojumuishwaMbali na vitendaji vilivyoainishwa na mtumiaji, JavaScript pia ina vitendaji vilivyojumuishwa.
Kwa mfano, kitendakazi cha isFinite kilichojengewa ndani hukuruhusu kuangalia ikiwa thamani iliyopitishwa ni nambari halali.
Document.write(isFinite(40)+"
"); document.write(isFinite(-590)+"
"); document.write(isFinite(90.33)+"
"); document.write(isFinite(NaN)+"
"); document.write(isFinite("Hii ni kamba")+"
");
Mtazamo wa haraka
Tafadhali kumbuka: unaweza kupata orodha kamili ya vitendaji vya JavaScript vilivyojengwa ndani yetu.
Vigezo vya ndani na kimataifaVigezo vilivyoundwa ndani ya vitendaji vinaitwa vigezo vya ndani. Unaweza kufikia vigezo hivyo tu ndani ya kazi ambazo zilifafanuliwa.
Baada ya msimbo wa kazi kukamilisha utekelezaji, vigezo vile vinaharibiwa. Hii ina maana kwamba vigezo na jina moja inaweza kuelezwa katika utendaji tofauti.
Vigezo vinavyoundwa nje ya msimbo wa utendaji huitwa vigeu vya kimataifa; vigeu hivyo vinaweza kufikiwa kutoka mahali popote kwenye msimbo.
Ukitangaza tofauti bila var ndani ya chaguo za kukokotoa, pia inakuwa ya kimataifa.
Vigezo vya kimataifa vinaharibiwa tu baada ya ukurasa kufungwa.
//Tamka vigeu vya kimataifa var1 na var2 var var1="var1 ipo"; var var2; kazi func1() ( //Agiza var2 thamani ndani ya chaguo za kukokotoa func1 var var2="var2 ipo"; ) //Kutoka kwa chaguo la kukokotoa lingine, chapisha yaliyomo katika kigezo cha var1 na var2 kwa kazi ya ukurasa func2() ( //Print yaliyomo katika hati ya kutofautisha ya var1.write( var1 + "
"); // Toa yaliyomo katika hati ya kutofautisha ya var2.write(var2); )
Mtazamo wa haraka
Kumbuka kuwa inapochapishwa kwenye skrini, var2 itakuwa na thamani tupu kwa sababu func1 inafanya kazi kwenye "toleo" la ndani la var2.
Kutumia Vipengele VisivyojulikanaVipengele ambavyo havina jina vinapotangazwa huitwa bila majina.
Chaguo za kukokotoa zisizojulikana kimsingi zimetangazwa kuwa hazitaitwa baadaye kutoka kwa nambari kama vitendakazi vya kawaida, lakini kupitishwa kwa vitendaji vingine kama kigezo.
Kazi arrMap(arr,func)( var res=new Array; kwa (var i=0;i
