Vitanzi vya JavaScript toa utekelezaji unaorudiwa wa hesabu zinazorudiwa. Wanaboresha mchakato wa kuandika nambari kwa kutekeleza maagizo sawa au kizuizi cha maagizo ambayo huunda mwili wa kitanzi, nambari iliyopewa nyakati (kwa kutumia kigeuzi cha kaunta) au hali iliyobainishwa ni kweli. Mizunguko inarudia juu ya mlolongo wa thamani. Utekelezaji wa kitanzi mara moja huitwa kurudia.

Utendaji wa kitanzi huathiriwa na idadi ya marudio na idadi ya shughuli zinazofanywa katika mwili wa kitanzi wa kila iteration.

Waendeshaji wa kitanzi wafuatao wapo kwenye JavaScript:

1) inatumika wakati unajua mapema ni mara ngapi unahitaji kufanya kitu;
2) kwa ... ndani hutumiwa kupitisha mali ya vitu;
3) wakati inatumiwa wakati hujui ni mara ngapi unahitaji kufanya kitu;
4) fanya...wakati unafanya kazi vivyo hivyo na operator wakati. Inatofautiana katika hilo fanya...wakati kila mara hutekeleza usemi huo katika viunga vya curly, lakini angalau mara moja, hata kama jaribio la hali litarudi kuwa sivyo.

Aina za vitanzi katika JavaScript, udhibiti wa kitanzi

1. Kwa kitanzi

Kitanzi cha for loop kinatumika kurudia kupitia vipengee vya safu au vitu kama safu kama vile hoja na HTMLCollection. Hali inaangaliwa kabla ya kila marudio ya kitanzi. Ikiwa hundi imefanikiwa, msimbo ndani ya kitanzi unatekelezwa, vinginevyo msimbo ndani ya kitanzi haufanyiki na programu inaendelea kutoka mstari wa kwanza mara moja baada ya kitanzi.

Kitanzi kinachofuata kitachapisha mstari Hujambo, JavaScript! Mara tano.

Kwa (var i = 0; i< 5; i++) { console.log(i + ": Hello, JavaScript!"); }
Mchele. 1. Matokeo ya kutekeleza kitanzi kwenye koni

1.1. Jinsi ya kitanzi inavyofanya kazi

Kwa kitanzi kina shughuli tatu tofauti:

Hatua ya 1. uanzishaji var i = 0; — tamko la kigeu cha kaunta ambacho kitaangaliwa wakati wa utekelezaji wa kitanzi. Tofauti hii imeanzishwa na thamani 0. Mara nyingi, vigeu vinavyoitwa i, j na k hufanya kama vihesabio vya kitanzi.

Hatua ya 2. ukaguzi wa hali i< 5; — условное выражение, если оно возвращает true , тело цикла (инструкция в фигурных скобках) будет выполнено. В katika mfano huu Hali inaangaliwa mradi tu thamani ya kaunta iwe chini ya 5.

Hatua ya 3. operesheni ya mwisho i++ - operesheni ya kuongeza nyongeza, huongeza thamani ya var i ya kutofautiana kwa moja. Badala ya operesheni ya kuongeza, operesheni ya kupungua pia inaweza kutumika.

Mwisho wa kitanzi, var i ya kutofautisha imehifadhiwa kwa 1. Urudiaji unaofuata wa kitanzi unatekelezwa kwa (var i = 1; i< 5; i++) { } . Условное выражение вычисляется снова, чтобы проверить, является ли значение счётчика i всё ещё меньше 5 . Если это так, операторы в теле цикла выполняются ещё раз. Завершающая операция снова увеличивает значение переменной на единицу. Шаги 2 и 3 повторяются до тех пор, пока условие i < 5; возвращает true .

1.2. Thamani za safu ya uchapishaji

Ili kuchapisha maadili ya safu kwa kutumia kitanzi, unahitaji kutumia mali ya urefu wa safu. Hii itakusaidia kuamua idadi ya vipengee katika safu na kitanzi idadi sawa ya nyakati.

Hati iliyo hapa chini itaonyesha ujumbe tano na majina ya rangi:

Var maua = ["Rose", "Lily", "Tulip", "Jasmine", "Orchid"]; kwa (var i = 0; i< flowers.length; i++){ alert(flowers[i] + " - это цветок."); }

Ikiwa thamani ya sifa ya urefu haibadilika wakati wa kitanzi, unaweza kuihifadhi katika tofauti ya ndani na kisha utumie utofauti huo katika usemi wa masharti. Kwa njia hii, unaweza kuongeza kasi ya kitanzi, kwa kuwa thamani ya mali ya urefu itapatikana mara moja tu wakati wa muda wote wa kitanzi.

Var maua = ["Rose", "Lily", "Tulip", "Jasmine", "Orchid"], len = flowers.length; kwa (var i = 0; i

2. Kitanzi kwa...ndani

Kwa ... katika vitanzi hutumiwa kupitisha mali ya vitu visivyo na safu. Njia hii ya kupita pia inaitwa uhamisho. Wakati wa kuvuka, inashauriwa kutumia njia hasOwnProperty() kuchuja mali ambazo zilirithiwa kutoka kwa mfano.

Kwa mfano, hebu tuunde kitu kwa kutumia kitu halisi.

Var user = ( jina: "Alice", umri: 25, nchi: "Urusi" ); kwa (var prop in user) ( console.log(prop + ": " + user);)
Mchele. 2. Matokeo ya kutekeleza kwa...katika kitanzi kwenye koni

Tuseme kwamba katika hali kabla au baada ya kitu cha mtumiaji kuundwa, mfano wa kitu cha Object ulipanuliwa. njia ya ziada clone().

Ikiwa (typeof Object.prototype.clone === "haijafafanuliwa") ( Object.prototype.clone = kazi () (); )

Kwa kuwa mlolongo wa urithi wa mfano unakaguliwa kila mara na mkalimani, vitu vyote hupata ufikiaji wa njia mpya kiatomati.

Mchele. 3. Matokeo ya kurudia kwa...katika kitanzi kwenye koni

Ili kuzuia ugunduzi wa njia hii wakati wa kuorodhesha sifa za kitu cha mtumiaji, njia ya hasOwnProperty() hutumiwa, ambayo itachuja sifa za mfano.

Var user = ( jina: "Alice", umri: 25, nchi: "Urusi" ); ikiwa (typeof Object.prototype.clone === "undefined") ( Object.prototype.clone = kazi () (); ) kwa (var prop katika mtumiaji) ( ikiwa (user.hasOwnProperty(prop)) ( console.log (prop + ": " + mtumiaji);
Mchele. 4. Matokeo ya kuorodhesha sifa za kitu kwa kutumia mbinu ya hasOwnProperty().

3. Wakati kitanzi

Wakati kitanzi - kitanzi na angalia mapema kujieleza kwa masharti. Taarifa iliyo ndani ya kitanzi (block of code in curly braces) itatekelezwa ikiwa usemi wa masharti utatathminiwa kuwa true . Ikiwa hundi ya kwanza itarudi kuwa sivyo, kizuizi cha maagizo hakitatekelezwa hata mara moja.

Baada ya marudio ya kitanzi kukamilika, usemi wa masharti hujaribiwa tena kwa ukweli na mchakato unarudiwa hadi usemi utathminiwe kuwa false . Katika kesi hii, programu itaendelea kutoka mstari wa kwanza mara baada ya kitanzi (ikiwa kuna moja).

Kitanzi hiki kitaonyesha jedwali la kuzidisha kwa nambari 3:

Var i = 1; var msg = ""; wakati (i< 10) { msg+= i + " x 3 = " + (i * 3) + "
"; i++; ) document.write(msg);
Mchele. 5. Matokeo ya kutekeleza kitanzi cha wakati

4. Fanya ... huku kitanzi

Kitanzi fanya...wakati; huangalia hali ya kuendelea baada ya kitanzi kutekelezwa. Tofauti na kitanzi cha wakati, katika kufanya ... wakati; Mwili wa kitanzi unatekelezwa angalau mara moja, kwani hali hiyo inachunguzwa mwishoni mwa kitanzi, na sio mwanzoni. Kitanzi hiki hutumiwa mara chache kuliko while , kwani katika mazoezi hali ambapo angalau utekelezaji wa kitanzi kimoja inahitajika ni nadra.

Var matokeo = ""; var i = 0; fanya ( i += 1; matokeo += i + ""; ) wakati (i< 5); document.write(result);
Mchele. 6. Matokeo ya kutekeleza do...wakati kitanzi

Katika mfano ufuatao, taarifa ndani ya kitanzi hutekelezwa mara moja, hata kama hali si kweli.

Var i = 10; fanya ( document.write(i + ""); i++; ) huku (i< 10);

5. Loops isiyo na mwisho

Unapounda kitanzi chochote, unaweza kuunda kitanzi kisicho na mwisho ambacho hakitaisha. Kitanzi kama hicho kinaweza kuendelea kufanya kazi mradi tu kompyuta ya mtumiaji inafanya kazi. Wengi vivinjari vya kisasa inaweza kugundua hii na kumfanya mtumiaji aache kuendesha hati. Ili kuepuka kuunda kitanzi kisicho na mwisho, lazima uwe na uhakika kwamba hali iliyotolewa itarudi uongo wakati fulani. Kwa mfano, kitanzi kifuatacho kinabainisha hali ambayo haitarudi kuwa sivyo kwa sababu sitakuwa chini ya 10:

Kwa (var i = 25; i > 10; i++) ( document.write("Sentensi hii itadumu milele...
"); }

6. Vitanzi vilivyowekwa

Kitanzi ndani ya kitanzi kingine kinaitwa kiota. Kwa kila marudio ya kitanzi, kitanzi kilichowekwa kiota kinatekelezwa kabisa. Vitanzi vilivyowekwa kiota vinaweza kuundwa kwa kutumia kitanzi na kitanzi cha muda.

Kwa (var count = 1; count< 3; count++) { document.write(count + ". Строка цикла
"); kwa (var nestcount = 1; nestcount< 3; nestcount++) { document.write("Строка вложенного цикла
"); } }
Mchele. 7. Matokeo ya kutekeleza kiota kwa kitanzi

7. Usimamizi wa mzunguko

Kitanzi kinaweza kudhibitiwa kwa kutumia taarifa za mapumziko; na kuendelea; .

7.1. mapumziko ya Opereta;

mapumziko ya Opereta; inamaliza utekelezaji wa kitanzi cha sasa. Inatumika katika hali za kipekee wakati kitanzi hakiwezi kutekeleza kwa sababu fulani, kama vile programu inapokutana na hitilafu. Mara nyingi mwendeshaji wa mapumziko; ni sehemu ya if construct.

Wakati taarifa hiyo inakatika; inatumika bila lebo, hukuruhusu kutoka kwa kitanzi au kubadili taarifa. Mfano ufuatao huunda kaunta ambayo thamani zake zinapaswa kuanzia 1 hadi 99, lakini taarifa ya mapumziko huvunja kitanzi baada ya marudio 14.

Kwa (var i = 1; i< 100; i++) { if (i == 15) { break; } document.write(i); document.write("
"); }
Mchele. 8. Matokeo ya mwendeshaji wa mapumziko kwenye kitanzi

Kwa vitanzi vilivyowekwa kiota, taarifa ya mapumziko; inayotumiwa na lebo inayokatisha maagizo yaliyopewa jina. Lebo hukuruhusu kutoka kwa kizuizi chochote cha msimbo. Maagizo yaliyotajwa yanaweza kuwa maagizo yoyote ya nje kwa mwendeshaji wa mapumziko; . Lebo inaweza kuwa jina la if taarifa au jina la block ya taarifa iliyoambatanishwa braces tu kukabidhi lebo kwenye kizuizi hiki. Kati ya neno kuu mapumziko; na jina la lebo haliruhusu laini mpya.

Kitanzi cha nje: kwa(var i = 0; i< 10; i++) { innerloop: for(var j = 0; j < 10; j++) { if (j >3) mapumziko; // Toka kitanzi cha ndani ikiwa (i == 2) vunja kitanzi cha ndani; // Kitu sawa ikiwa (i == 4) kuvunja outerloop; // Toka hati ya kitanzi cha nje. andika("i = " + i + "j = " + j + "
"); ) ) hati.andika("MWISHO i = " + i + " j = " + j + "
");

7.2. Opereta endelea;

Opereta endelea; husimamisha marudio ya sasa ya kitanzi na kuanza urudiaji mpya. Ambapo, wakati kitanzi inarudi moja kwa moja kwenye hali yake, na kwa kitanzi kwanza hutathmini usemi wa nyongeza na kisha kurudi kwenye hali.

Mfano huu utaonyesha nambari zote sawa:

Var i; kwa (i = 1; i<= 10; i++) { if (i % 2 !== 0) { continue; } document.write("
idadi sawa=" + i);)
Mchele. 9. Matokeo ya mwendeshaji endelea kwenye kitanzi

Opereta endelea; pia inaweza kutumika katika vitanzi vilivyowekwa kiota na lebo.

Kitanzi cha nje: kwa (var i = 0; i "); kwa (var j = 0; j "); ) ) document.write("Loops zote zimekamilika"+"
");
Mchele. 10. Matokeo ya mwendeshaji endelea na lebo

Moja ya zana muhimu zaidi katika programu ni vitanzi. Wao ni muhimu katika kesi ambapo unahitaji kufanya kitu idadi fulani ya nyakati.

Ikiwa kuna kazi kama hiyo, kwa mfano, kuonyesha mstari "hello kila mtu" mara 1000. Kisha, bila kutumia kitanzi, kwanza itachukua muda mwingi na pili, haitaonekana kuwa nzuri sana. Ndiyo maana unahitaji kujua mizunguko kikamilifu kwa sababu hutumiwa mara nyingi sana.

Kuna vitanzi vinne katika programu, haya ni wakati, fanya-wakati, kwa na mbele. Kila moja yao ina syntax yake na kila moja hutumiwa katika hali fulani.

Vitanzi vinavyotumika sana ni vya na foreach, ikifuatiwa na wakati, na kitanzi cha kufanya wakati ni nadra sana.

Na tutaanza na kitanzi cha wakati.

Syntax ya kitanzi cha wakati ni kama ifuatavyo:

Kwanza, tunatangaza kutofautiana i, ambayo ni counter, na ndani ya kitanzi tunaongeza counter hii. Ndani ya mabano tunaandika sharti la kuingia/kutoka kwenye kitanzi.

Maoni! Andika hali ya kuondoka kwa usahihi, vinginevyo inaweza kutokea kitanzi kisicho na mwisho na kisha hati itaganda

. Mzunguko kama huo unaweza kutokea ikiwa, kwa mfano, tunaandika kweli katika hali ya kutoka.

Kwa mfano, hebu tuchapishe kamba "Halo kila mtu!" mara 10.

Var i = 0; wakati(i"); i++;)

Tofauti naweza kuanza kutoka 0 au 1 au kutoka kwa nambari nyingine yoyote.

Hali ya kuondoka ni wakati huo huo hali ya kuingia. Kitanzi hufanya kazi kama ifuatavyo: Kwanza, inakagua ikiwa kutofautisha ni chini ya 10, na ikiwa hali ni kweli, basi tunaingiza kitanzi, vinginevyo, sivyo. Katika kesi hii, ikiwa kutofautisha i ni sawa na 30, kwa mfano, basi kitanzi hakitatekelezwa, kwa sababu 30 sio chini ya 10.

Tuliingia kwenye mzunguko, tukachapisha mstari "Hello kila mtu", tukaongeza counter na tena kwenda kwenye hali, ambapo tunaangalia tena ikiwa thamani ya kutofautiana i ni chini ya 10, kisha tunaingia kwenye mzunguko, vinginevyo tunatoka. Na hii hutokea mpaka wakati ambapo hali ya kuingia inakuwa ya uongo, yaani, thamani ya kutofautiana i itakuwa 10. 10 sio chini ya 10, kwa hiyo hatuingii tena kitanzi, lakini tuendelee.

Maoni!

Usisahau kuongeza kihesabu (i++), vinginevyo utaishia na kitanzi kisicho na kikomo.

Tumeshughulika na kitanzi cha wakati, sasa wacha tuendelee kwenye kitanzi cha kufanya wakati.

Sintaksia ya kitanzi cha kufanya-wakati ni kama ifuatavyo:

Tofauti kati ya kitanzi cha muda na kitanzi cha do-wakati ni kwamba kitanzi cha kufanya-wakati kinaweza kutekelezwa angalau mara moja, bila kujali hali, ambapo kitanzi cha muda hakitatekelezwa hata kidogo ikiwa hali ni ya uwongo.

Maoni!

Kama kitanzi cha wakati, usisahau kuongeza kihesabu cha i.

Tuendelee na mazoezi. Kwa mfano, hebu tuhesabu bidhaa ya nambari kutoka 1 hadi 10.

Kama nilivyoandika hapo juu, kitanzi cha kitanzi hufanyika mara nyingi, kwa hivyo unahitaji kuijua vizuri.

kwa syntax ya kitanzi inayofuata:

Kwa ufahamu bora, hebu tutatue tatizo rahisi. Wacha tuseme tunahitaji kuhesabu jumla ya nambari kutoka 1 hadi 1000 kwa kutumia kitanzi.

Var muhtasari = 0; kwa (var i = 1; i

Tunahifadhi hati, tuifungue kwenye kivinjari na uone kuwa matokeo ni 500500.

Maoni!

Ikiwa kuna kauli moja tu katika kitanzi, basi braces curly si lazima.

Ili kuonyesha, hebu tuonyeshe kamba kwenye skrini mara 5, kwa mfano "Hujambo!"

Kwa (var i = 1; i

Maoni!

Baada ya kitanzi kutekelezwa, thamani ya mwisho inabaki katika kutofautisha i.<= 100; i++){ document.write("привет!"); if(i % 10 == 0)  document.write("
Sasa hebu tutatue tatizo kidogo zaidi, kwa mfano tunahitaji kuchapisha kamba "Halo" mara 100. Na ili haya yote yasionekane kwenye safu moja, basi baada ya kila marudio ya 10, tunahamia kwenye mstari mpya. Na mwisho tutachapisha thamani ya kutofautisha i.

Kwa (var i = 1; i

"); ) hati.andika("

Tofauti i = " + i +""); // i = 101

kitanzi cha mbele Kawaida hutumika kurudia juu ya vitu na safu. Kwa hiyo, nitazungumzia juu yake katika makala inayoelezea kufanya kazi na safu.

taarifa ya kuvunja imekusudiwa kuondoka kwa kitanzi kwa nguvu.

Endelea mwendeshaji

hukuruhusu kukatiza urudiaji wa sasa wa kitanzi na kuendelea hadi inayofuata.<= 20; i++){ //Пропускаем текущею итерацию цикла if(i % 2 == 0) continue; summa += i; //Выходим совсем из цикла. if(i == 15) break; document.write(i + ". Итерация
Sasa hebu tutatue tatizo kidogo zaidi, kwa mfano tunahitaji kuchapisha kamba "Halo" mara 100. Na ili haya yote yasionekane kwenye safu moja, basi baada ya kila marudio ya 10, tunahamia kwenye mstari mpya. Na mwisho tutachapisha thamani ya kutofautisha i.

Kwa ufahamu bora, tutatatua pia shida rahisi. Wacha tuseme tunataka kuhesabu jumla ya nambari zisizo za kawaida kutoka 1 hadi 20. Na tunapofikia marudio ya 15, tutatoka kwenye kitanzi. Var muhtasari = 0; kwa (var i = 1; i

muhtasari

= " + muhtasari +"

"); //summa = 64

Tunahifadhi hati, tuifungue kwenye kivinjari na uangalie matokeo. Ili kufanya mazoezi, jaribu kubadilisha hati iliyoandikwa ili ihesabu jumla ya nambari sawa. Hii inamaliza makala hii. Sasa unajua syntax ya wakati, fanya-wakati, kwa vitanzi na jinsi ya kufanya kazi navyo.

. Pia tulikutana

kuvunja na kuendeleza kauli

Mizunguko

Ili kuelewa athari za kauli zenye masharti, tulipendekeza kuziwazia kama uma kwenye barabara ambayo mkalimani wa JavaScript husogea. Mizunguko inaweza kuzingatiwa kama zamu ya U kwenye barabara inayokurudisha nyuma, na hivyo kulazimisha mkalimani kupitia sehemu moja ya msimbo tena na tena.

Taarifa ya if ni taarifa ya msingi ya masharti katika JavaScript, na kitanzi cha msingi cha JavaScript ni kitanzi cha wakati. Ina syntax ifuatayo:

wakati (maneno) (maelekezo)

Kitanzi cha wakati huanza kwa kutathmini usemi. Usemi huu ukitathmini kuwa si kweli, mkalimani anaruka taarifa inayounda sehemu kuu ya kitanzi na kuendelea na kauli inayofuata katika programu. Ikiwa usemi unatathmini kuwa kweli, basi taarifa inayounda mwili wa kitanzi inatekelezwa, basi udhibiti huhamishwa hadi mwanzo wa kitanzi na usemi huo unatathminiwa tena. Kwa maneno mengine, mkalimani hutekeleza maagizo ya mwili wa kitanzi tena na tena mradi tu thamani ya usemi inabaki kuwa kweli. Tafadhali kumbuka kuwa inawezekana kuunda kitanzi kisicho na mwisho kwa kutumia sintaksia ya while(kweli).

Kwa kawaida hutaki mkalimani wa JavaScript atekeleze utendakazi sawa tena na tena. Katika karibu kila kitanzi, kwa kila iteration ya kitanzi, vigezo moja au zaidi hubadilisha maadili yao. Kwa sababu mabadiliko ya kubadilika, maagizo hufanya nini yanaweza kutofautiana kila wakati yanapopita kwenye mwili wa kitanzi.

Zaidi ya hayo, ikiwa viwezo vinavyorekebishwa vipo kwenye usemi, thamani ya usemi inaweza kubadilika kwa kila kupita kwa kitanzi. Hii ni muhimu kwa sababu vinginevyo usemi ambao thamani yake ilikuwa kweli hautabadilika na kitanzi hakitaisha! Ifuatayo ni mfano wa kitanzi cha muda ambacho huchapisha nambari kutoka 0 hadi 9:

Idadi ya var = 0; wakati (hesabu

Kama unavyoona, utofauti wa hesabu umewekwa hadi 0 mwanzoni, na kisha thamani yake inaongezwa kila wakati mwili wa kitanzi unatekelezwa. Baada ya kitanzi kutekelezwa mara 10, usemi utarudi kuwa sivyo (yaani, kutofautisha kwa hesabu sio chini ya 10), taarifa ya wakati itaisha, na mkalimani ataendelea na taarifa inayofuata katika programu. Vitanzi vingi vina vigeu vya kaunta sawa na kuhesabu. Mara nyingi, viambishi vinavyoitwa i, j, na k hufanya kama vihesabio vya kitanzi, ingawa ili kufanya msimbo wa programu ueleweke zaidi, unapaswa kuvipa vihesabio majina ya maelezo zaidi.

fanya/wakati kitanzi

Kitanzi cha kufanya/wakati kinafanana kwa njia nyingi na kitanzi cha muda, isipokuwa kwamba usemi wa kitanzi hujaribiwa mwishoni badala ya mwanzoni. Hii ina maana kwamba mwili wa kitanzi daima hutekelezwa angalau mara moja. Agizo hili lina syntax ifuatayo:

fanya (taarifa) wakati (maneno);

Kitanzi cha kufanya/wakati kinatumika mara chache zaidi kuliko dada yake wakati kitanzi. Ukweli ni kwamba katika mazoezi, hali wakati una uhakika mapema kwamba utahitaji kutekeleza mwili wa kitanzi angalau mara moja ni ya kawaida. Ifuatayo ni mfano wa kutumia kitanzi cha kufanya/wakati:

Kazi printArray(a) ( var len = a.length, i = 0; ikiwa (len == 0) console.log("Safu tupu"); vinginevyo ( fanya ( console.log(a[i]); ) wakati (++i

Kuna tofauti mbili kati ya kitanzi cha kufanya/wakati na kitanzi cha wakati cha kawaida. Kwanza, kitanzi cha kufanya kinahitaji neno kuu la kufanya (kuashiria kuanza kwa kitanzi) na neno kuu la wakati (kuashiria mwisho wa kitanzi na kutaja hali). Pili, tofauti na kitanzi cha muda, kitanzi cha do kinaisha na semicolon. Kitanzi cha muda hakihitaji kumalizika na semicolon ikiwa mwili wa kitanzi umefungwa kwa braces curly.

Tuendelee na mazoezi. Kwa mfano, hebu tuhesabu bidhaa ya nambari kutoka 1 hadi 10.

A kwa kitanzi ni muundo wa kitanzi ambao mara nyingi ni rahisi zaidi kuliko kitanzi cha muda. Kitanzi cha for hurahisisha kutengeneza vitanzi vinavyofuata muundo unaojulikana kwa vitanzi vingi. Vitanzi vingi vina aina fulani ya tofauti ya kukabiliana. Tofauti hii huanzishwa kabla ya kitanzi kuanza na huangaliwa kabla ya kila marudio. Hatimaye, kigezo cha kuhesabia kinaongezwa au kurekebishwa vinginevyo mwishoni mwa kitanzi, kabla tu ya utofauti kukaguliwa tena. Uanzishaji, uthibitishaji na usasishaji ni shughuli tatu muhimu zinazofanywa kwa kutofautisha kitanzi. Kwa taarifa hufanya hatua hizi tatu kuwa sehemu ya syntax ya kitanzi:

kwa(kuanzisha; kuangalia; kuongeza) (maagizo)

Anzisha, angalia, na uongeze ni semi tatu (zinazotenganishwa na nusukoloni) ambazo zina jukumu la kuanzisha, kuangalia, na kuongeza utofauti wa kitanzi. Kuziweka kwenye mstari wa kwanza wa kitanzi hurahisisha kuelewa ni nini for loop inafanya na hukuzuia kusahau kuanzisha au kuongeza utofauti wa kitanzi.

Njia rahisi ya kuelezea kwa kitanzi ni kuonyesha kitanzi sawa wakati:

uanzishaji; wakati(angalia) (maelekezo; ongezeko;)

Kwa maneno mengine, usemi wa uanzishaji hutathminiwa mara moja kabla ya kitanzi kuanza. Usemi huu kwa kawaida ni usemi wenye athari (kawaida mgawo). JavaScript pia inaruhusu usemi wa uanzishaji kuwa taarifa ya tamko la kutofautiana, kwa hivyo inawezekana kutangaza na kuanzisha kihesabu kitanzi kwa wakati mmoja.

Usemi wa jaribio hutathminiwa kabla ya kila marudio na huamua ikiwa sehemu ya kitanzi itatekelezwa. Ikiwa matokeo ya mtihani ni kweli, maagizo ambayo ni mwili wa kitanzi hutekelezwa. Mwishoni mwa kitanzi, usemi wa nyongeza hutathminiwa. Ili usemi huu uwe na maana, ni lazima uwe usemi wenye madhara. Kwa kawaida hii huwa ni usemi wa mgawo au usemi unaotumia opereta ++ au --.

Unaweza pia kuchapisha nambari 0 hadi 9 ukitumia kitanzi, kama inavyoonyeshwa hapa chini, kinyume na kitanzi sawa na kilichoonyeshwa kwenye mfano hapo awali:

Kwa (var count = 0; count

Kwa kweli, vitanzi vinaweza kuwa ngumu zaidi kuliko mifano hii rahisi, na wakati mwingine anuwai nyingi hubadilika katika kila iteration ya kitanzi. Hali hii ndio wakati pekee katika JavaScript ambapo opereta comma hutumiwa mara nyingi - hukuruhusu kuchanganya uanzishaji mwingi na misemo ya kuongeza kuwa usemi mmoja unaofaa kutumika kwa kitanzi:

Var i,j; kwa (i = 0, j = 0; i

kwa/katika kitanzi

Kitanzi cha/katika kinatumia kwa neno kuu, lakini ni tofauti kabisa na kitanzi cha kawaida. Kwa/katika kitanzi kina syntax ifuatayo:

kwa (kubadilika kwa kitu) (taarifa)

Tofauti hapa kawaida ni jina la kutofautisha, lakini pia unaweza kutumia taarifa ya var, ambayo inatangaza tofauti moja. Kigezo cha kitu ni usemi unaorudisha kitu. Na kama kawaida, maagizo ni maagizo au kizuizi cha maagizo ambayo huunda mwili wa kitanzi.

Ili kuvuka vipengele vya safu, ni kawaida kutumia kawaida kwa kitanzi:

Var arr = ; kwa (var i = 0; i

Kwa/katika taarifa pia kwa kawaida hukuruhusu kupitisha mali ya kitu:

// Unda kitu kipya var obj = (jina:"Alex", nenosiri:"12345" ); kwa (var i in obj) ( // Chapisha thamani ya kila kitu kiweko cha mali.log(obj[i]); )

Ili kutekeleza kwa/katika taarifa, mkalimani wa JavaScript kwanza hutathmini kitu cha kujieleza. Iwapo itarejesha null au isiyofafanuliwa, mkalimani ataruka kitanzi na kuendelea na kauli inayofuata. Ikiwa usemi unarudisha thamani rahisi, inabadilishwa kuwa kitu sawa cha kanga. Vinginevyo, usemi hurudisha kitu. Mkalimani kisha atekeleze mrudisho mmoja wa kitanzi kwa kila mali inayoweza kuhesabika ya kitu. Kabla ya kila marudio, mkalimani hutathmini thamani ya usemi, huihifadhi katika kigezo, na kuipatia jina la sifa (thamani ya mfuatano).

Mara nyingi sana unahitaji sehemu fulani ya programu kutekelezwa mara nyingi. Kwa kweli, unaweza kufanya hivi: nakala na ubandike nambari inayotakiwa ya nyakati. Walakini, hii ni upuuzi, haswa ikiwa hatua lazima ifanyike, kwa mfano, mara 1000. Ndio maana kuna wanaoitwa mizunguko, ambayo inapatikana katika lugha nyingi za programu. Nami nitakuambia juu yao.

Ina msimbo mahususi ambao husogezwa mara nyingi. Kuna aina kadhaa za mzunguko: kwa, wakati Na kufanya-wakati.

Wacha tuanze na mzunguko wa kwanza (na maarufu zaidi) - kwa kitanzi. Muonekano wa jumla wa mzunguko huu ni kama ifuatavyo.

Kwa (iteration_variable = original_value; condition; action_after_each_iteration) (
// msimbo wa programu
}

Ngoja nitoe maoni yangu kwa kilichoandikwa hapa. Kwanza inakuja - kutofautiana kwa kurudia. Hili ni jina la kawaida la kutofautisha kwa kurudia. Inayofuata inakuja thamani_ya_anzilishi. Kwa kweli, jina linajieleza lenyewe. Inayofuata inakuja sharti, inapotimizwa (yaani, inarudi kweli) kitanzi kinaendeshwa mara moja zaidi, na hatimaye kitendo ambacho hutekelezwa baada ya kila marudio. Kwa kawaida hii ni mabadiliko ya kutofautiana kwa iteration.

Wacha tuandike hati rahisi ambayo itaonyesha idadi ya marudio ya kitanzi:

Kwa (i = 0; i< 100; i++)
document.write(i + "");

Hapa tumeweka kutofautisha kwa iteration (inayoitwa i), ambayo ilipewa thamani 0 . Ifuatayo, hali inakaguliwa: i< 100 . Ikiwa inatekelezwa, basi iteration moja ya kitanzi inatekelezwa. Baada ya kila marudio kukamilika, i++(Hiyo ni, kuongeza kutofautisha i juu 1 ) Hali hiyo inaangaliwa tena, na ikiwa ni kweli, basi marudio mengine yanafanywa. Na kadhalika mpaka hali i< 100 haitakuwa uongo. Ni wazi, itakuwa ya uwongo tu baada ya marudio 100. Kwa hivyo, kitanzi hiki kitatekelezwa mara 100, ambayo tunaweza kuona ikiwa tutaendesha hati hii. Na jambo moja zaidi. Kwa kuwa tuna mwendeshaji mmoja tu aliyetekelezwa hapa ( hati.andika()), basi uwepo wa braces curly ni chaguo. Ikiwa una waendeshaji 2 au zaidi wanaoendesha kwenye kitanzi, basi unahitaji kuwaweka.

Sasa hebu tuzungumze kuhusu aina ya pili loops katika JavaScript - wakati. Kimsingi, mzunguko ni sawa na kwa(ingawa mizunguko yote ni sawa). Lakini hapa maoni ya jumla ni tofauti:

Wakati (hali) (
// msimbo wa programu
}

Kama unaweza kuona, hakuna kutofautisha kwa kurudia, wala vitendo vyovyote baada ya kurudia. Hitimisho linafuata kutoka kwa hili: ili kutoka kwa kitanzi, ni muhimu kufanya hivyo kwenye kitanzi yenyewe ili " hali" imekuwa ya uwongo. Ikiwa hii haijafanywa, kitanzi kitatokea, na, kwa hivyo, hati yako itaning'inia.

Wacha tutekeleze kazi sawa na hapo awali, lakini kwa kutumia wakati kitanzi.

Var i = 0;
wakati (i< 100) {
i++;
document.write(i + "");
}

Kabla ya kuanza kitanzi tuliunda kutofautiana i, ambayo ilipewa thamani ya awali. Kisha, kabla ya kuanza kitanzi, hali hiyo inachunguzwa, na ikiwa ni kweli, basi iteration ya kitanzi imezinduliwa, ambayo sisi huongeza kutofautiana kwa iteration (vinginevyo kitanzi kitatokea). Na sisi kuonyesha variable hii.

Na hatimaye, mtazamo wa mwisho loops katika JavaScript - kufanya-wakati kitanzi. Sintaksia ni:

Fanya (
// msimbo wa programu
) wakati (hali)

Inafanana sana na mzunguko wakati, hata hivyo, kuna moja tu, lakini tofauti ya msingi sana. Kama wakati kitanzi Kwanza inakagua hali hiyo, na kisha inatekeleza iteration au la. Hiyo kufanya-wakati kitanzi kwanza hufanya iteration, na kisha tu kuangalia hali. Na ikiwa ni ya uwongo, hutoka kwenye kitanzi. Kwa maneno mengine, bila kujali hali, kitanzi hiki kinahakikishiwa kutekelezwa angalau mara moja. Nadhani nambari hii itakuwa ya ziada, lakini bado.

Var i = 0;
fanya (
i++;
document.write(i + "");
) wakati (i< 100)

Sitaelezea nambari, nina hakika utaijua bila mimi. Kwa hivyo ni bora niende kwa waendeshaji wawili wa kupendeza: mapumziko Na endelea.

Hebu tuanze na mapumziko. Opereta huyu hukuruhusu kuruka nje ya kitanzi mapema. Wacha tuandike nambari ifuatayo:

Kwa (i = 0; i< 100; i++) {
ikiwa (i == 50) kuvunja;
document.write(i + "");
}

Unaweza kuendesha hati hii na kupata nambari tu hadi 49 , tangu lini mimi = 50 mzunguko uliingiliwa, shukrani kwa operator mapumziko.

Sasa ninazungumza juu ya mwendeshaji endelea. Opereta huyu hukuruhusu kuhamia kwa kurudia tena kwa kitanzi. Ili usielezee sana hapa, ni bora kuonyesha mfano mara moja:

Kwa (i = 0; i< 100; i++) {
ikiwa (i == 50) itaendelea;
document.write(i + "");
}

Ukiendesha hati hii, utaona kuwa nambari haipo 50 . Hii ilitokea kwa sababu lini mimi = 50, tunaendelea kwenye iteration inayofuata ya kitanzi, kabla ya hapo i huongezeka kwa 1 na inakuwa sawa 51.

Hiyo, inaonekana, ndio tu nilitaka kuandika juu yake Mizunguko ya JavaScript. Natumai kila kitu kimekuwa wazi kwako. Unaweza pia kuja na shida kwako mwenyewe na kulitatua. Hii itakuwa Workout kubwa.

Mizunguko ni misemo maalum ambayo hukuruhusu kutekeleza kizuizi sawa cha nambari mara kadhaa. Utekelezaji wa kanuni huingiliwa wakati hali fulani inatokea.

JavaScript inatoa watengenezaji programu aina kadhaa mizunguko. Hebu tuangalie kwa karibu zaidi.

Kitanzi na counter

Mzunguko na kihesabu ni rahisi ikiwa nambari fulani inahitaji kutekelezwa kwa idadi iliyobainishwa kabisa ya nyakati. Hii labda ndiyo aina ya kawaida ya mzunguko.

Kitanzi kilicho na counter kimeandikwa kama hii:

kwa (<выражение инициализации>; <условие>; <приращение>)
<тело цикла>

Neno la msingi linatumika hapa. Kwa hiyo, vitanzi vile mara nyingi huitwa "kwa vitanzi".

Usemi wa uanzishaji unatekelezwa kwanza na mara moja tu. Inapeana kigezo maalum kinachoitwa kihesabu kitanzi kwa thamani fulani ya awali (kawaida 1). Kaunta ya kitanzi huhesabu ni mara ngapi sehemu ya kitanzi—msimbo halisi unaohitaji kutekelezwa mara kadhaa—imetekelezwa.

Hatua inayofuata ni kuangalia hali. Huamua wakati ambapo utekelezaji wa kitanzi utakatizwa na nambari ifuatayo itaanza kutekelezwa. Kwa kawaida, hali inalinganisha thamani ya counter ya kitanzi na thamani yake iliyofungwa. Ikiwa hali inarudi kweli, mwili wa kitanzi unatekelezwa, vinginevyo kitanzi kinaisha na msimbo unaofuata kitanzi huanza kutekelezwa.

Baada ya kupita mwili mzunguko Usemi wa nyongeza unatekelezwa, kubadilisha thamani ya kaunta. Usemi huu kwa kawaida huongeza kaunta (huongeza thamani yake kwa moja). Ifuatayo, hali hiyo inachunguzwa tena, mwili wa kitanzi unatekelezwa, ongezeko linatekelezwa, nk, mpaka hali inakuwa ya uongo.

Mfano wa kitanzi kilicho na kihesabu:

kwa (i = 1; i< 11; i++) {
a +=3;
b = i * 2 + 1;
}

Kitanzi hiki kitatekelezwa mara 10. Tunaweka counter i thamani ya awali ya 1 na baada ya kila utekelezaji wa mwili wa kitanzi tunaiongeza kwa moja. Kitanzi kitaacha kutekeleza wakati counter inapoongezeka hadi 11 na hali ya kitanzi inakuwa ya uongo.

Kaunta ya kitanzi inaweza kuandikwa katika moja ya misemo ya mwili wa kitanzi, kama tulivyofanya. Kwa upande wetu, counter i itakuwa na maadili yanayoongezeka kwa mlolongo kutoka 1 hadi 10, ambayo hutumiwa katika mahesabu.

Hapa kuna mifano miwili zaidi ya kitanzi kilicho na kihesabu:

kwa (i = 10; i > 0; i--) (
a +=3;
b = i * 2 + 1;
}

Hapa thamani ya kaunta imepunguzwa. Thamani yake ya awali ni 10. Kitanzi kitatekelezwa mara 10 na kitaisha wakati counter i ina 0; katika kesi hii, maadili ya mwisho yatapungua mfululizo kutoka 10 hadi 1.

kwa (i = 2; i< 21; i += 2) b = i * 2 + 1;

Na katika mfano huu, thamani ya awali ya counter ni 2, na thamani ya mwisho ni 21, lakini kitanzi kitatekelezwa, tena, mara 10. Na yote kwa sababu thamani ya counter inaongezeka kwa 2 na mfululizo inachukua maadili 2, 4, 6 ... 20.

Kitanzi kilicho na hali ya posta

Kitanzi cha postcondition ni kama kitanzi cha kaunta: kinatumika mradi tu hali ya kitanzi ibaki kuwa kweli. Zaidi ya hayo, hali hiyo haijaangaliwa kabla, lakini baada ya utekelezaji wa mwili wa kitanzi, ndiyo sababu kitanzi kilicho na hali ya posta kilipata jina lake. Kitanzi kama hicho kitatekelezwa angalau mara moja, hata ikiwa hali yake ni ya uwongo tangu mwanzo.

Umbizo la kitanzi na hali ya posta:

fanya
<тело цикла>
wakati (<условие>);

Ili kufafanua kitanzi na hali ya posta, maneno muhimu ya kufanya na wakati yametolewa, ndiyo sababu vitanzi kama hivyo mara nyingi huitwa "loops za kufanya-wakati."

Hapa kuna mfano wa kitanzi kilicho na hali ya posta:

fanya (
a = a * i + 2;
++i;
) wakati (a< 100);

Hapa kuna mfano mwingine:

var a = 0, i = 1;
fanya (
a = a * i + 2;
++i;
) wakati (i< 20);

Ingawa hapa itakuwa rahisi zaidi kutumia kitanzi na counter ambayo tayari inajulikana kwetu na iliyoundwa mahsusi kwa kesi kama hizo.

Kitanzi kilicho na masharti

Mzunguko na sharti hutofautiana na kitanzi kilicho na hali ya posta kwa kuwa hali hiyo inaangaliwa kabla ya kutekeleza mwili wa kitanzi. Kwa hivyo, ikiwa (hali) hapo awali ni ya uwongo, kitanzi hakitatekelezwa hata mara moja:

wakati (<условие>)
<тело цикла>

Ili kuunda kitanzi na hali ya posta, neno kuu la wakati limetolewa. Kwa hiyo, vitanzi vile pia huitwa "wakati vitanzi" (sio kuchanganyikiwa na "loops za kufanya-wakati"!).

Mfano wa kitanzi kilicho na sharti:

wakati (a< 100) {
a = a * i + 2;
++i;
}

Kukatiza na kuanzisha upya mzunguko

Wakati mwingine ni muhimu kukatiza utekelezaji wa kitanzi. Ili kufanikisha hili, JavaScript huwapa waandaaji programu wa Wavuti taarifa za kuvunja na kuendelea.

Opereta ya mapumziko hukuruhusu kukatiza utekelezaji wa kitanzi na kuendelea na usemi unaofuata:

wakati (a< 100) {
a = a * i + 2;
ikiwa (a> 50) kuvunja;
++i;
}

Katika mfano huu, tunavunja kitanzi ikiwa thamani ya kutofautiana a itazidi 50.

Taarifa ya kuendelea na kuanzisha upya hukuruhusu kuwasha upya mzunguko, yaani, kuacha maneno yote yanayofuata yaliyojumuishwa kwenye mwili wa kitanzi bila kutekelezwa, na kuanza kutekeleza kitanzi tangu mwanzo: kuangalia hali, kutekeleza ongezeko na mwili, nk.

Mfano:

wakati (a< 100) {
i = ++i;
ikiwa (i> 9 && i< 11) continue;
a = a * i + 2;
}

Hapa tunaruka usemi unaotathmini a, kwa maadili yote i kutoka 10 hadi 20.