Gelung JavaScript menyediakan pelaksanaan berulang pengiraan berulang. Mereka mengoptimumkan proses menulis kod dengan melaksanakan arahan atau blok arahan yang sama yang membentuk badan gelung, nombor yang diberi kali (menggunakan pembolehubah pembilang) atau semasa keadaan yang dinyatakan adalah benar. Gelung berulang pada jujukan nilai. Melaksanakan gelung sekali dipanggil lelaran.

Prestasi gelung dipengaruhi oleh bilangan lelaran dan bilangan operasi yang dilakukan dalam badan gelung setiap lelaran.

Pengendali gelung berikut wujud dalam JavaScript:

1) untuk digunakan apabila anda mengetahui terlebih dahulu berapa kali anda perlu melakukan sesuatu;
2) for...in digunakan untuk melintasi sifat objek;
3) manakala digunakan apabila anda tidak tahu berapa kali anda perlu melakukan sesuatu;
4) lakukan...sambil bekerja sama dengan operator manakala. Ia berbeza dalam do...sambil sentiasa melaksanakan ungkapan dalam pendakap kerinting, tetapi sekurang-kurangnya sekali, walaupun ujian keadaan mengembalikan false .

Jenis gelung dalam JavaScript, kawalan gelung

1. Untuk gelung

Gelung for digunakan untuk melelaran melalui elemen tatasusunan atau objek seperti tatasusunan seperti argumen dan HTMLCollection. Keadaan diperiksa sebelum setiap lelaran gelung. Jika semakan berjaya, kod di dalam gelung dilaksanakan, jika tidak, kod di dalam gelung tidak dilaksanakan dan program diteruskan dari baris pertama serta-merta mengikuti gelung.

Gelung seterusnya akan mencetak baris Hello, JavaScript! Lima kali.

Untuk (var i = 0; i< 5; i++) { console.log(i + ": Hello, JavaScript!"); }
nasi. 1. Hasil daripada melaksanakan gelung for pada konsol

1.1. Bagaimana gelung for berfungsi

Gelung for terdiri daripada tiga operasi berbeza:

Langkah 1. permulaan var i = 0; — pengisytiharan pembolehubah pembilang yang akan disemak semasa pelaksanaan gelung. Pembolehubah ini dimulakan dengan nilai 0. Selalunya, pembolehubah bernama i, j dan k bertindak sebagai pembilang gelung.

Langkah 2. pemeriksaan keadaan i< 5; — условное выражение, если оно возвращает true , тело цикла (инструкция в фигурных скобках) будет выполнено. В dalam contoh ini Keadaan disemak selagi nilai kaunter kurang daripada 5.

Langkah 3. operasi akhir i++ - operasi kenaikan balas, meningkatkan nilai pembolehubah var i sebanyak satu. Daripada operasi kenaikan, operasi pengurangan juga boleh digunakan.

Pada penghujung gelung, pembolehubah var i disimpan pada 1. Lelaran seterusnya bagi gelung dilaksanakan untuk (var i = 1; i< 5; i++) { } . Условное выражение вычисляется снова, чтобы проверить, является ли значение счётчика i всё ещё меньше 5 . Если это так, операторы в теле цикла выполняются ещё раз. Завершающая операция снова увеличивает значение переменной на единицу. Шаги 2 и 3 повторяются до тех пор, пока условие i < 5; возвращает true .

1.2. Mencetak nilai tatasusunan

Untuk mencetak nilai tatasusunan menggunakan gelung for, anda perlu menggunakan sifat panjang tatasusunan. Ini akan membantu anda menentukan bilangan elemen dalam tatasusunan dan gelung bilangan kali yang sama.

Skrip di bawah akan memaparkan lima mesej dengan nama warna:

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

Jika nilai sifat panjang tidak berubah semasa gelung, anda boleh menyimpannya dalam pembolehubah tempatan dan kemudian menggunakan pembolehubah itu dalam ungkapan bersyarat. Dengan cara ini, anda boleh meningkatkan kelajuan gelung, kerana nilai sifat panjang akan diambil sekali sahaja sepanjang tempoh keseluruhan gelung.

Bunga Var = ["Rose", "Lily", "Tulip", "Jasmine", "Orkid"], len = bunga.panjang; untuk (var i = 0; i

2. Gelung untuk...dalam

Untuk...dalam gelung digunakan untuk melintasi sifat objek bukan tatasusunan. Pintasan ini juga dipanggil pemindahan. Semasa melintasi, disyorkan untuk menggunakan kaedah hasOwnProperty() untuk menapis sifat yang diwarisi daripada prototaip.

Sebagai contoh, mari kita cipta objek menggunakan literal objek.

Pengguna Var = ( nama: "Alice", umur: 25, negara: "Rusia" ); untuk (var prop dalam pengguna) ( console.log(prop + ": " + pengguna); )
nasi. 2. Hasil pelaksanaan gelung for...in pada konsol

Katakan bahawa dalam senario sebelum atau selepas objek pengguna dicipta, prototaip objek Objek telah dilanjutkan kaedah tambahan klon() .

Jika (typeof Object.prototype.clone === "undefined") ( Object.prototype.clone = function () (); )

Oleh kerana rantaian warisan prototaip sentiasa diperiksa oleh jurubahasa, semua objek secara automatik mendapat akses kepada kaedah baharu.

nasi. 3. Hasil pengulangan gelung for...in pada konsol

Untuk mengelakkan pengesanan kaedah ini semasa menghitung sifat objek pengguna, kaedah hasOwnProperty() digunakan, yang akan menapis sifat prototaip.

Pengguna Var = ( nama: "Alice", umur: 25, negara: "Rusia" ); if (typeof Object.prototype.clone === "undefined") ( Object.prototype.clone = function () (); ) untuk (var prop dalam pengguna) ( if (user.hasOwnProperty(prop)) ( console.log (prop + ": " + pengguna); ) )
nasi. 4. Hasil penyenaraian sifat objek menggunakan kaedah hasOwnProperty().

3. Gelung manakala

Manakala gelung - gelung dengan pra-semak ungkapan bersyarat. Pernyataan di dalam gelung (blok kod dalam pendakap kerinting) akan dilaksanakan jika ungkapan bersyarat bernilai benar . Jika semakan pertama mengembalikan false , blok arahan tidak akan dilaksanakan walaupun sekali.

Selepas lelaran gelung selesai, ungkapan bersyarat diuji sekali lagi untuk kebenaran dan proses diulang sehingga ungkapan bernilai false . Dalam kes ini, program akan diteruskan dari baris pertama sejurus selepas gelung (jika ada).

Gelung ini akan memaparkan jadual pendaraban untuk nombor 3:

Var i = 1; var msg = ""; Sementara saya< 10) { msg+= i + " x 3 = " + (i * 3) + "
"; i++; ) document.write(msg);
nasi. 5. Hasil pelaksanaan gelung while

4. Lakukan...while loop

Gelung buat...sambil; menyemak keadaan kesinambungan selepas gelung dilaksanakan. Berbeza dengan gelung while, in do...while; Badan gelung dilaksanakan sekurang-kurangnya sekali, kerana keadaan disemak pada penghujung gelung, dan bukan pada permulaan. Gelung ini digunakan kurang kerap berbanding while , kerana dalam amalan situasi di mana sekurang-kurangnya satu pelaksanaan gelung diperlukan jarang berlaku.

Hasil Var = ""; var i = 0; lakukan ( i += 1; hasil += i + " "; ) manakala (i< 5); document.write(result);
nasi. 6. Hasil pelaksanaan gelung do...while

Dalam contoh berikut, pernyataan dalam gelung dilaksanakan sekali, walaupun keadaannya tidak benar.

Var i = 10; lakukan ( document.write(i + " "); i++; ) manakala (i< 10);

5. Gelung tak terhingga

Apabila anda mencipta sebarang gelung, anda boleh mencipta gelung tak terhingga yang tidak akan berakhir. Gelung sedemikian berpotensi terus berjalan selagi komputer pengguna sedang berjalan. Majoriti pelayar moden boleh mengesan ini dan menggesa pengguna untuk berhenti menjalankan skrip. Untuk mengelak daripada mencipta gelung tidak berkesudahan, anda mesti yakin bahawa syarat yang diberikan akan kembali palsu pada satu ketika. Sebagai contoh, gelung berikut menentukan syarat yang tidak pernah mengembalikan palsu kerana saya tidak akan kurang daripada 10:

Untuk (var i = 25; i > 10; i++) ( document.write("Ayat ini akan berjalan selama-lamanya...
"); }

6. Gelung bersarang

Satu gelung di dalam gelung lain dipanggil bersarang. Dengan setiap lelaran gelung, gelung bersarang dilaksanakan sepenuhnya. Gelung bersarang boleh dibuat menggunakan gelung for dan gelung while.

Untuk (var count = 1; count< 3; count++) { document.write(count + ". Строка цикла
"); untuk (var nestcount = 1; nestcount< 3; nestcount++) { document.write("Строка вложенного цикла
"); } }
nasi. 7. Hasil pelaksanaan gelung bersarang untuk

7. Pengurusan kitaran

Gelung boleh dikawal menggunakan penyataan putus; dan teruskan; .

7.1. Rehat operator;

Rehat operator; menamatkan pelaksanaan gelung semasa. Ia digunakan dalam kes luar biasa apabila gelung tidak dapat dilaksanakan atas sebab tertentu, seperti jika aplikasi menghadapi ralat. Selalunya pengendali rehat; adalah sebahagian daripada konstruk if.

Apabila kenyataan itu pecah; digunakan tanpa label, ia membolehkan anda keluar dari pernyataan gelung atau suis. Contoh berikut mencipta pembilang yang nilainya harus berkisar antara 1 hingga 99, tetapi pernyataan rehat memecahkan gelung selepas 14 lelaran.

Untuk (var i = 1; i< 100; i++) { if (i == 15) { break; } document.write(i); document.write("
"); }
nasi. 8. Hasil daripada operator putus dalam gelung for

Untuk gelung bersarang, pernyataan putus; digunakan dengan label yang menamatkan arahan yang dinamakan. Label membolehkan anda keluar dari mana-mana blok kod. Arahan yang dinamakan boleh menjadi sebarang arahan di luar kepada operator rehat; . Label boleh menjadi nama pernyataan if atau nama blok pernyataan yang disertakan pendakap gigi hanya untuk memberikan label pada blok ini. antara kata kunci pecah; dan nama label tidak membenarkan baris baharu.

Gelung luar: untuk(var i = 0; i< 10; i++) { innerloop: for(var j = 0; j < 10; j++) { if (j >3) rehat; // Keluar dari gelung paling dalam jika (i == 2) memecahkan gelung dalam; // Perkara yang sama jika (i == 4) memecahkan gelung luar; // Keluar dokumen gelung luar.write("i = " + i + " j = " + j + "
"); ) ) document.write("AKHIR i = " + i + " j = " + j + "
");

7.2. Operator teruskan;

Operator teruskan; menghentikan lelaran semasa gelung dan memulakan lelaran baharu. Di mana, gelung semasa kembali terus kepada keadaannya, dan untuk gelung mula-mula menilai ungkapan kenaikan dan kemudian kembali kepada keadaan.

Contoh ini akan memaparkan semua nombor genap:

Var i; untuk(i = 1; i<= 10; i++) { if (i % 2 !== 0) { continue; } document.write("
nombor genap= " + i); )
nasi. 9. Hasil daripada operator continue dalam gelung for

Operator teruskan; juga boleh digunakan dalam gelung bersarang dengan label.

Outerloop: untuk (var i = 0; i "); untuk (var j = 0; j "); ) ) document.write("Semua gelung selesai"+"
");
nasi. 10. Hasil daripada operator teruskan dengan label

Salah satu alat yang paling penting dalam pengaturcaraan ialah gelung. Mereka berguna dalam kes di mana anda perlu melakukan sesuatu beberapa kali.

Jika terdapat tugas sedemikian, sebagai contoh, untuk memaparkan baris "hello everyone" 1000 kali. Kemudian, tanpa menggunakan gelung, pertama ia akan mengambil banyak masa dan kedua, ia tidak akan kelihatan sangat bagus. sebab tu anda perlu mengetahui kitaran dengan sempurna kerana ia digunakan sangat, sangat kerap.

Terdapat empat gelung dalam pengaturcaraan, ini ialah sambil, buat-sementara, untuk dan untuk. Setiap daripada mereka mempunyai sintaks sendiri dan setiap satu digunakan dalam kes tertentu.

Gelung yang paling biasa digunakan ialah for dan foreach, diikuti dengan while, dan gelung do-while sangat jarang berlaku.

Dan kita akan mulakan dengan gelung sementara.

Sintaks gelung while adalah seperti berikut:

Mula-mula, kami mengisytiharkan pembolehubah i, iaitu pembilang, dan di dalam gelung kami menambah pembilang ini. Di dalam kurungan kita menulis syarat untuk memasuki/keluar gelung.

Komen! Tulis syarat keluar dengan betul, jika tidak, ia mungkin berlaku gelung tak terhingga dan kemudian skrip akan membeku. Kitaran sedemikian boleh berlaku jika, sebagai contoh, kita hanya menulis benar dalam keadaan keluar.

Sebagai contoh, mari kita cetak rentetan "Hello semua!" 10 kali.

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

Pembolehubah i boleh bermula dari 0 atau 1 atau dari mana-mana nombor lain.

Keadaan keluar adalah pada masa yang sama syarat kemasukan. Gelung berfungsi seperti berikut: Pertama, ia menyemak sama ada pembolehubah i adalah kurang daripada 10, dan jika keadaan itu benar, maka kita masukkan gelung, jika tidak, tidak. Dalam kes ini, jika pembolehubah i adalah sama dengan 30, sebagai contoh, maka gelung tidak akan dilaksanakan, kerana 30 tidak kurang daripada 10.

Kami memasuki kitaran, mencetak baris "Hello semua", menambah kaunter dan sekali lagi pergi ke keadaan, di mana kami sekali lagi menyemak sama ada nilai pembolehubah i kurang daripada 10, kemudian kami memasuki kitaran, jika tidak, kami keluar darinya. Dan ini berlaku sehingga saat keadaan kemasukan menjadi palsu, iaitu, nilai pembolehubah i akan menjadi 10. 10 tidak kurang daripada 10, jadi kita tidak lagi memasuki gelung, tetapi teruskan.

Komen! Jangan lupa untuk menambah pembilang (i++), jika tidak, anda akan mendapat gelung tak terhingga.

Kami telah menangani gelung sementara, sekarang mari kita beralih kepada gelung buat sambil.

Sintaks gelung do-while adalah seperti berikut:

Perbezaan antara gelung sementara dan gelung do-while ialah gelung do-while boleh dilaksanakan sekurang-kurangnya sekali, tanpa mengira keadaan, manakala gelung sementara tidak akan dilaksanakan sama sekali jika syarat itu palsu.

Komen! Sama seperti gelung while, jangan lupa untuk menambah pembilang i.

Mari kita teruskan untuk berlatih. Sebagai contoh, mari kita mengira hasil darab nombor dari 1 hingga 10.

Var i = 1; var pengeluaran = 1; lakukan(pengeluaran *= i; i++; )sementara(i

Hasilnya akan menjadi nombor 3628800. Pada langkah pertama, kami segera memasuki gelung, walaupun keadaannya, di mana pengeluaran operasi *= i dilakukan (ini adalah sama dengan pengeluaran = pengeluaran * 1). Kemudian kita menambah kaunter. Selepas kenaikan, ia mempunyai nilai 2. Dan pada akhirnya kita menyemak keadaan, jika nilai pembilang kurang daripada atau sama dengan 10, maka kita pergi ke lelaran seterusnya gelung, jika tidak, kita keluar dari gelung dan teruskan .

untuk gelung

Seperti yang saya tulis di atas, gelung for berlaku agak kerap, jadi anda perlu mengetahuinya dengan baik.

untuk sintaks gelung seterusnya:

Untuk pemahaman yang lebih baik, mari kita selesaikan masalah mudah. Katakan kita perlu mengira jumlah nombor dari 1 hingga 1000 menggunakan gelung for.

Var summa = 0; untuk(var i = 1; i

Kami menyimpan dokumen itu, buka dalam penyemak imbas dan lihat hasilnya ialah 500500.

Komen! Jika terdapat hanya satu pernyataan dalam gelung, maka pendakap kerinting tidak diperlukan.

Untuk menunjukkan, mari kita paparkan beberapa rentetan pada skrin sebanyak 5 kali, contohnya "Hello!"

Untuk(var i = 1; i

Komen! Selepas gelung dilaksanakan, nilai terakhir kekal dalam pembolehubah i.

Sekarang mari kita selesaikan masalah ini sedikit lebih rumit, sebagai contoh kita perlu mencetak rentetan "Hello" 100 kali. Dan supaya semua ini tidak muncul dalam satu baris, maka selepas setiap lelaran ke-10, kami beralih ke baris baru. Dan pada akhirnya kita akan mencetak nilai pembolehubah i.

Untuk(var i = 1; i<= 100; i++){ document.write("привет!"); if(i % 10 == 0)  document.write("
"); ) document.write("

Pembolehubah i = " + i + "

"); // i = 101

foreach gelung Biasanya digunakan untuk mengulangi objek dan tatasusunan. Oleh itu, saya akan membincangkannya dalam artikel yang menerangkan bekerja dengan tatasusunan.

pecah kenyataan bertujuan untuk keluar dari gelung secara paksa.

Teruskan operator membolehkan anda mengganggu lelaran semasa gelung dan beralih ke yang seterusnya.

Untuk pemahaman yang lebih baik, kami juga akan menyelesaikan masalah mudah. Katakan kita mahu mengira jumlah nombor ganjil dari 1 hingga 20. Dan apabila kita mencapai lelaran ke-15, kita akan keluar dari gelung.

Var summa = 0; untuk(var i = 1; i<= 20; i++){ //Пропускаем текущею итерацию цикла if(i % 2 == 0) continue; summa += i; //Выходим совсем из цикла. if(i == 15) break; document.write(i + ". Итерация
"); ) document.write("

summa= " + summa + "

"); //summa = 64

Kami menyimpan dokumen, buka dalam penyemak imbas dan lihat hasilnya.

Untuk berlatih, cuba tukar skrip bertulis supaya ia mengira jumlah nombor genap.

Ini menamatkan artikel ini. Sekarang anda tahu sintaks while, do-while, untuk gelung dan cara bekerja dengannya. Kami pun berjumpa pecah dan teruskan kenyataan.

Kitaran

Untuk memahami kesan pernyataan bersyarat, kami mencadangkan untuk membayangkannya sebagai persimpangan jalan di mana jurubahasa JavaScript bergerak. Gelung boleh dianggap sebagai pusingan U di jalan yang membawa anda kembali, memaksa jurubahasa untuk membaca sekeping kod yang sama berulang kali.

JavaScript mempunyai empat gelung: while, do/while, for, dan for/in. Satu daripada subseksyen berikut dikhaskan untuk setiap daripadanya. Satu kegunaan umum gelung adalah untuk melintasi elemen tatasusunan.

gelung semasa

Pernyataan if ialah pernyataan bersyarat asas dalam JavaScript, dan gelung asas untuk JavaScript ialah gelung while. Ia mempunyai sintaks berikut:

manakala (ungkapan) (arahan)

Gelung while bermula dengan menilai ungkapan. Jika ungkapan ini dinilai palsu, jurubahasa melangkau pernyataan yang membentuk badan gelung dan beralih ke pernyataan seterusnya dalam atur cara. Jika ungkapan menilai kepada benar, maka pernyataan yang membentuk badan gelung dilaksanakan, kemudian kawalan dipindahkan ke permulaan gelung dan ungkapan dinilai semula. Dalam erti kata lain, jurubahasa melaksanakan arahan badan gelung berulang kali selagi nilai ungkapan itu kekal benar. Sila ambil perhatian bahawa adalah mungkin untuk mencipta gelung tak terhingga menggunakan sintaks while(true).

Biasanya anda tidak mahu jurubahasa JavaScript melakukan operasi yang sama berulang kali. Dalam hampir setiap gelung, dengan setiap lelaran gelung, satu atau lebih pembolehubah menukar nilainya. Oleh kerana pembolehubah berubah, perkara yang dilakukan oleh arahan mungkin berbeza setiap kali ia melalui badan gelung.

Selain itu, jika pembolehubah yang diubah suai hadir dalam ungkapan, nilai ungkapan mungkin berubah dengan setiap pas gelung. Ini penting kerana jika tidak, ungkapan yang nilainya benar tidak akan berubah dan gelung tidak akan berakhir! Di bawah ialah contoh gelung sementara yang mencetak nombor dari 0 hingga 9:

Kiraan var = 0; manakala (kira

Seperti yang anda lihat, pembolehubah kiraan ditetapkan kepada 0 pada permulaan, dan kemudian nilainya dinaikkan setiap kali badan gelung dilaksanakan. Selepas gelung telah dilaksanakan 10 kali, ungkapan akan kembali palsu (iaitu, pembolehubah kiraan tidak lagi kurang daripada 10), pernyataan sementara akan berakhir, dan penterjemah akan beralih ke pernyataan seterusnya dalam atur cara. Kebanyakan gelung mempunyai pembolehubah pembilang yang serupa dengan kiraan. Selalunya, pembolehubah bernama i, j, dan k bertindak sebagai pembilang gelung, walaupun untuk menjadikan kod program lebih mudah difahami, anda harus memberikan pembilang nama yang lebih deskriptif.

gelung do/while

Gelung do/while adalah serupa dalam banyak cara dengan gelung sementara, kecuali ungkapan gelung diuji pada penghujung dan bukannya pada permulaan. Ini bermakna badan gelung sentiasa dilaksanakan sekurang-kurangnya sekali. Arahan ini mempunyai sintaks berikut:

lakukan (pernyataan) sambil (ungkapan);

Gelung do/while digunakan kurang kerap berbanding gelung while kakaknya. Hakikatnya ialah dalam amalan, keadaan apabila anda pasti terlebih dahulu bahawa anda perlu melaksanakan badan gelung sekurang-kurangnya sekali adalah agak luar biasa. Di bawah ialah contoh menggunakan gelung do/while:

Fungsi printArray(a) ( var len = a.length, i = 0; if (len == 0) console.log("Array kosong"); else ( do ( console.log(a[i]); ) manakala (++i

Terdapat dua perbezaan antara gelung do/while dan gelung while biasa. Pertama, gelung do memerlukan kedua-dua kata kunci do (untuk menandakan permulaan gelung) dan kata kunci while (untuk menandakan penghujung gelung dan menentukan syarat). Kedua, tidak seperti gelung sementara, gelung do berakhir dengan koma bertitik. Gelung sementara tidak perlu diakhiri dengan koma bertitik jika badan gelung disertakan dengan pendakap kerinting.

untuk gelung

A untuk gelung ialah binaan gelung yang selalunya lebih mudah daripada gelung sementara. Gelung for memudahkan untuk membina gelung yang mengikut corak yang biasa kepada kebanyakan gelung. Kebanyakan gelung mempunyai beberapa jenis pembolehubah balas. Pembolehubah ini dimulakan sebelum gelung bermula dan diperiksa sebelum setiap lelaran. Akhir sekali, pemboleh ubah pembilang dinaikkan atau diubah suai pada penghujung badan gelung, sejurus sebelum pembolehubah disemak semula. Permulaan, pengesahan dan kemas kini ialah tiga operasi utama yang dilakukan pada pembolehubah gelung. Pernyataan for menjadikan tiga langkah ini sebagai sebahagian daripada sintaks gelung:

untuk(permulaan; menyemak; kenaikan) (arahan)

Permulaan, semak dan kenaikan ialah tiga ungkapan (dipisahkan dengan koma bertitik) yang bertanggungjawab untuk memulakan, menyemak dan menambah pembolehubah gelung. Meletakkannya pada baris pertama gelung menjadikannya lebih mudah untuk memahami perkara yang dilakukan oleh gelung for dan menghalang anda daripada terlupa untuk memulakan atau menambah pembolehubah gelung.

Cara paling mudah untuk menerangkan gelung for adalah dengan menunjukkan gelung while yang setara:

permulaan; while(check) ( arahan; kenaikan; )

Dalam erti kata lain, ungkapan permulaan dinilai sekali sebelum gelung bermula. Ungkapan ini biasanya merupakan ungkapan dengan kesan sampingan (biasanya tugasan). JavaScript juga membenarkan ungkapan permulaan menjadi pernyataan pengisytiharan pembolehubah var, jadi adalah mungkin untuk mengisytiharkan dan memulakan pembilang gelung pada masa yang sama.

Ungkapan ujian dinilai sebelum setiap lelaran dan menentukan sama ada badan gelung akan dilaksanakan. Jika keputusan ujian adalah benar, arahan yang merupakan badan gelung dilaksanakan. Pada penghujung gelung, ungkapan kenaikan dinilai. Untuk ungkapan ini bermakna, ia mestilah ungkapan yang mempunyai kesan sampingan. Biasanya ini adalah sama ada ungkapan tugasan atau ungkapan menggunakan operator ++ atau --.

Anda juga boleh mencetak nombor 0 hingga 9 menggunakan gelung for, seperti yang ditunjukkan di bawah, berbanding gelung while yang setara yang ditunjukkan dalam contoh sebelum ini:

Untuk (var count = 0; count

Sudah tentu, gelung boleh menjadi lebih kompleks daripada contoh mudah ini, dan kadangkala berbilang pembolehubah berubah dalam setiap lelaran gelung. Situasi ini merupakan satu-satunya masa dalam JavaScript di mana pengendali koma sering digunakan - ia membolehkan anda menggabungkan berbilang pemulaan dan penambahan ungkapan ke dalam satu ungkapan yang sesuai untuk digunakan dalam gelung for:

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

untuk/dalam gelung

Gelung untuk/dalam menggunakan kata kunci untuk, tetapi ia sama sekali berbeza daripada gelung untuk biasa. Gelung untuk/dalam mempunyai sintaks berikut:

untuk (pembolehubah dalam objek) (penyataan)

Pembolehubah di sini biasanya nama pembolehubah, tetapi anda juga boleh menggunakan pernyataan var, yang mengisytiharkan pembolehubah tunggal. Parameter objek ialah ungkapan yang mengembalikan objek. Dan seperti biasa, arahan ialah arahan atau blok arahan yang membentuk badan gelung.

Untuk melintasi elemen tatasusunan, adalah wajar untuk menggunakan gelung for biasa:

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

Pernyataan untuk/dalam juga secara semula jadi membolehkan anda melintasi sifat objek:

// Cipta objek baharu var obj = (nama:"Alex", kata laluan:"12345" ); for (var i in obj) ( // Cetak nilai setiap objek property console.log(obj[i]); )

Untuk melaksanakan pernyataan untuk/dalam, jurubahasa JavaScript terlebih dahulu menilai objek ungkapan. Jika ia mengembalikan null atau undefined, penterjemah melangkau gelung dan beralih ke pernyataan seterusnya. Jika ungkapan mengembalikan nilai mudah, ia ditukar kepada objek pembalut yang setara. Jika tidak, ungkapan mengembalikan objek. Jurubahasa kemudian melaksanakan satu lelaran gelung untuk setiap harta objek yang boleh dikira. Sebelum setiap lelaran, jurubahasa menilai nilai ungkapan, menyimpannya dalam pembolehubah dan memberikannya nama sifat (nilai rentetan).

Selalunya anda memerlukan bahagian tertentu program untuk dilaksanakan berkali-kali. Sudah tentu, anda hanya boleh melakukan ini: salin dan tampal bilangan kali yang diperlukan. Walau bagaimanapun, ini adalah tidak masuk akal, terutamanya jika tindakan itu mesti dilakukan, contohnya, 1000 kali. Itulah sebabnya ada yang dipanggil kitaran, yang terdapat dalam kebanyakan bahasa pengaturcaraan. Dan saya akan memberitahu anda tentang mereka.

Mengandungi kod tertentu yang ditatal beberapa kali. Terdapat beberapa jenis kitaran: untuk, sementara Dan buat-sambil.

Mari kita mulakan dengan kitaran pertama (dan yang paling popular) - untuk gelung. Penampilan umum kitaran ini adalah seperti berikut:

Untuk (pembolehubah_lelaran = nilai_awal; syarat; tindakan_selepas_setiap_lelaran) (
//kod program
}

Izinkan saya mengulas apa yang ditulis di sini. Pertama datang - pembolehubah lelaran. Ini ialah nama pembolehubah biasa untuk lelaran. Seterusnya datang nilai_permulaan. Sebenarnya, nama itu bercakap untuk dirinya sendiri. Seterusnya datang syarat, apabila dipenuhi (iaitu, ia kembali benar) gelung dijalankan sekali lagi, dan akhirnya tindakan yang dilaksanakan selepas setiap lelaran. Biasanya ini adalah perubahan kepada pembolehubah untuk lelaran.

Mari tulis skrip ringkas yang akan memaparkan bilangan lelaran gelung:

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

Di sini kami telah menetapkan pembolehubah untuk lelaran (dipanggil i), yang telah diberikan nilai 0 . Seterusnya keadaan diperiksa: i< 100 . Jika ia dilaksanakan, maka satu lelaran gelung dilaksanakan. Selepas setiap lelaran selesai, i++(iaitu, meningkatkan pembolehubah i pada 1 ). Keadaan diperiksa semula, dan jika ia benar, maka lelaran lain dilakukan. Dan seterusnya sehingga syarat i< 100 tidak akan menjadi palsu. Jelas sekali, ia akan palsu hanya selepas 100 lelaran. Oleh itu, gelung ini akan dilaksanakan 100 kali, yang boleh kita lihat jika kita menjalankan skrip ini. Dan satu lagi perkara. Oleh kerana kami hanya mempunyai satu operator yang dilaksanakan di sini ( document.write()), maka kehadiran pendakap kerinting adalah pilihan. Jika anda mempunyai 2 atau lebih pengendali berjalan dalam satu gelung, maka anda perlu memasangnya.

Sekarang mari kita bercakap tentang jenis kedua gelung dalam JavaScript - sementara. Pada asasnya, kitaran ini sangat serupa dengan untuk(walaupun semua kitaran adalah serupa). Tetapi di sini pandangan umum adalah berbeza:

Manakala (syarat) (
//kod program
}

Seperti yang anda lihat, tiada pembolehubah untuk lelaran, mahupun sebarang tindakan selepas lelaran. Kesimpulan berikut dari ini: untuk keluar dari gelung, perlu melakukannya dalam gelung itu sendiri supaya " syarat" telah menjadi palsu. Jika ini tidak dilakukan, gelung akan berlaku dan, akibatnya, skrip anda akan digantung.

Mari kita laksanakan tugas yang sama seperti sebelumnya, tetapi menggunakan gelung semasa.

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

Sebelum memulakan gelung kami mencipta pembolehubah i, yang telah diberikan nilai awal. Kemudian, sebelum memulakan gelung, keadaan diperiksa, dan jika ia benar, maka lelaran gelung dilancarkan, di mana kita menambah pembolehubah untuk lelaran (jika tidak gelung akan berlaku). Dan kami memaparkan pembolehubah ini.

Dan akhirnya pandangan terakhir gelung dalam JavaScript - gelung do-while. Sintaksnya ialah:

buat(
//kod program
) manakala (syarat)

Sangat serupa dengan kitaran sementara, bagaimanapun, terdapat hanya satu, tetapi perbezaan yang sangat asas. Jika gelung semasa Mula-mula ia menyemak keadaan, dan kemudian ia melaksanakan lelaran atau tidak. Itu gelung do-while mula-mula ia melakukan lelaran, dan hanya kemudian menyemak keadaan. Dan jika ia palsu, ia keluar dari gelung. Dalam erti kata lain, tanpa mengira syarat, gelung ini dijamin akan dilaksanakan sekurang-kurangnya sekali. Saya fikir kod ini akan berlebihan, tetapi masih.

Var i = 0;
buat (
i++;
document.write(i + " ");
) Sementara saya< 100)

Saya tidak akan menerangkan kod itu, saya pasti anda akan memahaminya tanpa saya. Jadi lebih baik saya beralih kepada dua pengendali yang menarik: rehat Dan teruskan.

Mari kita mulakan dengan rehat. Operator ini membolehkan anda melompat keluar dari gelung lebih awal. Mari tulis kod berikut:

Untuk (i = 0; i< 100; i++) {
jika (i == 50) putus;
document.write(i + " ");
}

Anda boleh menjalankan skrip ini dan mendapati bahawa hanya nombor sehingga 49 , sejak bila i = 50 gelung telah terganggu, terima kasih kepada pengendali rehat.

Sekarang saya bercakap tentang pengendali teruskan. Operator ini membenarkan anda beralih ke lelaran gelung seterusnya. Untuk tidak menerangkan terlalu banyak di sini, lebih baik tunjukkan contoh dengan segera:

Untuk (i = 0; i< 100; i++) {
jika (i == 50) teruskan;
document.write(i + " ");
}

Jika anda menjalankan skrip ini, anda akan melihat bahawa nombor itu tiada 50 . Ini berlaku kerana apabila i = 50, kita beralih kepada lelaran seterusnya bagi gelung, sebelum itu i meningkat sebanyak 1 dan menjadi sama ke-51.

Nampaknya, itu sahaja yang saya ingin tulis gelung JavaScript. Saya harap semuanya telah menjadi jelas kepada anda. Anda juga boleh membuat masalah untuk diri sendiri dan menyelesaikannya. Ini akan menjadi senaman yang hebat.

Kitaran ialah ungkapan khas yang membolehkan anda melaksanakan blok kod yang sama beberapa kali. Pelaksanaan kod terganggu apabila keadaan tertentu berlaku.

JavaScript menawarkan pengaturcara beberapa jenis kitaran. Mari kita lihat mereka dengan lebih dekat.

Gelung dengan pembilang

Kitaran dengan kaunter adalah mudah jika beberapa kod perlu dilaksanakan beberapa kali yang ditetapkan dengan ketat. Ini mungkin jenis kitaran yang paling biasa.

Gelung dengan pembilang ditulis seperti ini:

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

Kata kunci untuk digunakan di sini. Oleh itu, gelung sedemikian sering dipanggil "untuk gelung".

Ungkapan permulaan dilaksanakan pertama sekali dan sekali sahaja. Ia memberikan pembolehubah khas yang dipanggil pembilang gelung kepada beberapa nilai awal (biasanya 1). Pembilang gelung mengira berapa kali badan gelung—kod sebenar yang perlu dilaksanakan beberapa kali tertentu—telah dilaksanakan.

Langkah seterusnya ialah menyemak keadaan. Ia menentukan masa apabila pelaksanaan gelung akan terganggu dan kod berikut akan mula dilaksanakan. Biasanya, keadaan membandingkan nilai pembilang gelung dengan nilai terikatnya. Jika keadaan kembali benar, badan gelung dilaksanakan, jika tidak gelung berakhir dan kod yang mengikuti gelung memulakan pelaksanaan.

Selepas melepasi badan kitaran Ungkapan kenaikan dilaksanakan, menukar nilai pembilang. Ungkapan ini biasanya menambah pembilang (meningkatkan nilainya sebanyak satu). Seterusnya, keadaan diperiksa semula, badan gelung dilaksanakan, kenaikan dilaksanakan, dsb., sehingga keadaan menjadi palsu.

Contoh gelung dengan pembilang:

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

Gelung ini akan dilaksanakan sebanyak 10 kali. Kami memberikan kaunter i nilai awal 1 dan selepas setiap pelaksanaan badan gelung kami menambahnya dengan satu. Gelung akan berhenti melaksanakan apabila pembilang meningkat kepada 11 dan keadaan gelung menjadi palsu.

Pembilang gelung boleh ditulis dalam salah satu ungkapan badan gelung, seperti yang kita lakukan. Dalam kes kami, kaunter i akan mengandungi nilai yang meningkat secara berurutan dari 1 hingga 10, yang digunakan dalam pengiraan.

Berikut ialah dua lagi contoh gelung dengan pembilang:

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

Di sini nilai kaunter dikurangkan. Nilai awalnya ialah 10. Gelung akan dilaksanakan 10 kali dan akan berakhir apabila pembilang i mengandungi 0; dalam kes ini, nilai yang terakhir akan menurun berturut-turut daripada 10 kepada 1.

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

Dan dalam contoh ini, nilai awal pembilang ialah 2, dan nilai akhir ialah 21, tetapi gelung akan dilaksanakan, sekali lagi, 10 kali. Dan semuanya kerana nilai pembilang meningkat sebanyak 2 dan berturut-turut mengambil nilai 2, 4, 6... 20.

Gelung dengan postcondition

Gelung postcondition sama seperti gelung balas: ia berjalan selagi keadaan gelung kekal benar. Selain itu, keadaan diperiksa bukan sebelum ini, tetapi selepas pelaksanaan badan gelung, itulah sebabnya gelung dengan postcondition mendapat namanya. Gelung sedemikian akan dilaksanakan sekurang-kurangnya sekali, walaupun keadaannya palsu dari awal lagi.

Format gelung dengan postcondition:

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

Untuk menentukan gelung dengan postcondition, kata kunci do dan while disediakan, itulah sebabnya gelung tersebut sering dipanggil "do-while loop."

Berikut ialah contoh gelung dengan postcondition:

buat (
a = a * i + 2;
++i;
) manakala (a< 100);

Berikut adalah contoh lain:

var a = 0, i = 1;
buat (
a = a * i + 2;
++i;
) Sementara saya< 20);

Walaupun di sini adalah lebih mudah untuk menggunakan gelung dengan kaunter yang sudah biasa kepada kami dan direka khas untuk kes sedemikian.

Gelung dengan prasyarat

Kitaran dengan prasyarat berbeza daripada gelung dengan postcondition kerana keadaan itu disemak sebelum melaksanakan badan gelung. Jadi, jika ia (syarat) pada mulanya palsu, gelung tidak akan dilaksanakan walaupun sekali:

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

Untuk membuat gelung dengan postcondition, kata kunci while disediakan. Oleh itu, gelung sedemikian juga dipanggil "gelung semasa" (jangan dikelirukan dengan "gelung lakukan-sementara"!).

Contoh gelung dengan prasyarat:

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

Mengganggu dan memulakan semula kitaran

Kadang-kadang perlu untuk mengganggu pelaksanaan gelung. Untuk mencapai matlamat ini, JavaScript menyediakan pengaturcara Web dengan penyataan rehat dan teruskan.

Operator rehat membolehkan anda mengganggu pelaksanaan gelung dan beralih ke ungkapan seterusnya:

manakala (a< 100) {
a = a * i + 2;
jika (a > 50) pecah;
++i;
}

Dalam contoh ini, kita memecahkan gelung jika nilai pembolehubah a akan melebihi 50.

Pernyataan teruskan semula membolehkan anda memulakan semula kitaran, iaitu, biarkan semua ungkapan berikutnya termasuk dalam badan gelung tidak dilaksanakan, dan mula melaksanakan gelung dari awal lagi: menyemak keadaan, melaksanakan kenaikan dan badan, dsb.

Contoh:

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

Di sini kita melangkau ungkapan yang menilai a, untuk semua nilai i dari 10 hingga 20.