Pembelajaran gelung JS: penggunaan pernyataan gelung sementara (contoh terperinci)

Gelung ialah melakukan satu perkara berulang kali Dalam proses menulis kod, kita sering menghadapi beberapa operasi yang perlu dilakukan berulang kali, seperti merentasi beberapa data dan berulang kali mengeluarkan rentetan. . Tunggu, ia akan menjadi terlalu menyusahkan untuk menulis baris demi baris Untuk operasi berulang ini, kita harus memilih untuk menggunakan gelung untuk menyelesaikannya.

Tujuan gelung adalah untuk melaksanakan berulang kali sekeping kod tertentu Menggunakan gelung boleh mengurangkan tekanan pengaturcaraan, mengelakkan redundansi kod, meningkatkan kecekapan pembangunan dan memudahkan penyelenggaraan kemudian. Gelung while ialah pernyataan gelung termudah yang disediakan dalam JavaScript Mari kita pelajari tentang penggunaan gelung while dan gelung do-while.

1: gelung while

penyataan gelung while ialah penyataan gelung 当型 Keadaan gelung pertama kali dinilai Apabila syarat dipenuhi, badan gelung adalah dilaksanakan. Berhenti apabila tidak berpuas hati.

Fungsi: Ulang operasi sehingga syarat yang dinyatakan tidak benar.

Ciri: Nilai ungkapan dahulu, dan laksanakan pernyataan yang sepadan apabila hasil ungkapan adalah benar.

1. Sintaks gelung semasa JS

while(表达式){    //表达式为循环条件
     // 要执行的代码
}

Analisis penyata:

• Kira dahulu Nilai "ungkapan", apabila nilainya benar, melaksanakan "blok pernyataan PHP" dalam badan gelung; FALSE), jika ia adalah nilai jenis lain, ia secara automatik akan ditukar kepada nilai jenis Boolean (kerana PHP adalah jenis bahasa yang lemah dan secara automatik akan menukar pembolehubah kepada jenis data yang betul berdasarkan nilai pembolehubah).

  "Blok pernyataan" ialah koleksi satu atau lebih pernyataan yang dikelilingi oleh
  ; jika terdapat hanya satu pernyataan dalam blok pernyataan,

  juga boleh ditinggalkan.

  { }{ }
  

  Selepas pelaksanaan selesai, kembali ke ungkapan dan hitung nilai ungkapan itu sekali lagi untuk penghakiman Apabila nilai ungkapan adalah benar, teruskan laksanakan "blok pernyataan" ...Proses ini akan diulang

• sehingga nilai ungkapan palsu sebelum melompat keluar dari gelung dan melaksanakan pernyataan di bawah sambil.
Carta alir pernyataan while adalah seperti berikut:

Biasanya "ungkapan" ialah menggunakan perbandingan Nilai yang dikira oleh operator atau operator logik

adalah seperti berikut:

<script>
var i = 1;
while( i <= 5) {
    document.write(i+", ");
    i++;
}
</script>

Nota

Apabila menulis pernyataan gelung, pastikan anda memastikan bahawa hasil ungkapan bersyarat boleh palsu (iaitu nilai Boolean palsu), kerana selagi hasil ungkapan Jika benar, gelung akan berterusan selama-lamanya dan tidak akan berhenti secara automatik Untuk gelung jenis ini yang tidak boleh berhenti secara automatik, kita biasanya memanggilnya "gelung tak terhingga" atau "gelung tak terhingga".

Jika anda membuat gelung tak terhingga secara tidak sengaja, ia boleh menyebabkan penyemak imbas atau komputer menjadi beku.

Jika ungkapan sentiasa benar dan keadaan gelung sentiasa benar, gelung while akan terus dilaksanakan dan tidak akan berakhir, menjadi "gelung tak terhingga"

Selepas menjalankan atur cara , ia akan meneruskan Output nilai pembolehubah

sehingga pengguna memaksanya untuk ditutup.

var i = 1;
while(i){
    console.log(i);
}

icontoh gelung while JS

[Contoh 1] Gunakan gelung while untuk mengira jumlah semua integer antara 1~100:

Hasil Keluaran:

<script>
var i = 1;
var sum=0;
while(i<=100){
	sum+=i;
	i++;
}
console.log("1加到100的值为："+sum);
</script>

[Contoh 2] Cari semua tahun lompat antara 1900 dan 2020, dan keluarkan dengan 6 setiap baris:

<script>
var i = 1900;
var count = 0; //计数闰年的个数
while (i <= 2020) {
    //判断是否是闰年
    if (i % 4 == 0 && i % 100 != 0 || i % 400 == 0) {
        document.write(i + "  ");
        count++;
        if (count % 6 == 0) {
            document.write("<br/>");
        }
    }
    i++;
}
</script>

2. JS while loop bersarang struktur

while loop juga boleh mencapai kesan bersarang gelung bersarang di dalam gelung sementara.

Format tatabahasa:

while(条件1){
     // 条件1成立执行的代码

     while(条件2){
          // 条件2成立执行的代码
           ......
     }
}

Ringkasan:

Bersarang bermaksud kemasukan Yang dipanggil sarang gelung semasa ialah Ada a while bersarang di dalam while Sintaks asas setiap while adalah sama dengan yang sebelumnya.

Di sini, kami mentakrifkan sarang dua gelung sambil Sudah tentu, kami boleh membuat sarang seberapa banyak gelung sementara yang kami mahu.

Fahami proses pelaksanaan gelung sambil

Apabila gelung dalam selesai, penghakiman bersyarat bagi gelung luar seterusnya dilaksanakan.

Contoh 1: Gunakan gelung bersarang untuk mencetak pembilang

<script type="text/javascript">
	var i = 0;
	while(i < 2){
	   console.log("i =", i);
	   var j = 0;
	   while(j < 2){
		console.log("\tj =", j);
		j += 1;
	   }
	   i++;
	}
	console.log("Over");
</script>

首先，我们定义了一个最外层的 while 循环嵌套，计数器 变量 i 从 0 开始，结束条件是 i

在最外层循环的里面，同时又定义了一个内部循环，计数器变量 j 从 0 开始，结束条件是 i

while循环嵌套总结

JavaScript 的 while 循环也可以实现嵌套的效果，即 while 循环里面嵌套一个或多个 while 循环。

示例2：

<script>
/*
1. 循环打印3次媳妇，我错了
2. 刷碗
3. 上面是一套惩罚，这一套惩罚重复执行3天----一套惩罚要重复执行---放到一个while循环里面
*/
var j = 0
while(j < 3){
    var i = 0
    while(i < 3){
        document.write(&#39;媳妇，我错了<br>&#39;)
        i += 1;
	}
    document.write(&#39;刷碗<br>&#39;)
	document.write(&#39;一套惩罚就结束了!!!!!!!!!!!!<br>&#39;)
    j += 1;
}
</script>

二：do-while循环

除了while循环，还有一种 do-while 循环。

do-while循环语句是一种“直到型”循环语句，它是先在执行了一次循环体中的“语句块”之后，然后再对循环条件进行判断，如果为真则继续循环，如果为假，则终止循环。

因此：不论表达式的结果，do-while循环语句至少会执行一次“语句块”。

do-while循环语句的特点：先执行循环体，然后判断循环条件是否成立。

1、JS do-while 循环语法

do{
    语句块;  
}while(表达式);//表达式为循环条件

语句解析：

• 先执行一次循环体中的“语句块”，然后判断“表达式”的值，当“表达式”的值为真时，返回重新执行循环体中的语句块……这个过程会一直重复

• 直到表达式的值为假时，跳出循环，此时循环结束，执行后面的语句。

说明：

• 和while循环一样，do-while循环中“表达式”的计算结果一定是布尔型的 TRUE 或 FALSE，如果是其他类型的值也会自动转换为布尔类型的值。

• do-while语句最后的分号;是无法省略的（一定要有），它是do while循环语法的一部分。

do-while循环语句的流程图如下所示：

JS do-while 循环示例

【示例1】使用 do-while 输出1~5数字：

<script>
var i = 1;
do {
    document.write(i+", ");
    i++;
}while( i <= 5);
</script>

【示例2】使用 while 循环计算 1~100 之间所有整数的和：

<script>
var i = 1;
var sum=0;
do{
	sum+=i;
	i++;
}while(i<=100);
console.log("1 + 2 + 3 + ... + 98 + 99 + 100 = "+sum);
</script>

【示例3】找出 1900 年到 2020 年之间所有的闰年

<script>
var i = 1900;
var count = 0; //计数闰年的个数
do {
    //判断是否是闰年
    if (i % 4 == 0 && i % 100 != 0 || i % 400 == 0) {
		console.log(i);
    }
    i++;
}while (i <= 2020);
</script>

2、JS do-while 循环嵌套结构

do while循环 也可以实现嵌套的效果，即 do while 循环里面嵌套一个或多个 do while 循环。这种写法就类似于 while 循环 的嵌套。

语法：

do{
    // 语句块1;
    do{
    	// 语句块2;
    	do{
    		// 语句块2;
    		......
	}while(条件3);
    }while(条件2);
}while(条件1);

这里，我们定义了三个 do while 循环的嵌套，当然，我们可以嵌套任意多个的 do while 循环。

案例：使用循环嵌套，打印计数器

<script type="text/javascript">
	var i = 0;
	do{
		console.log("i =", i);
		var j = 0;
		do{
			console.log("\tj =", j);
			j += 1;
		}while(j < 2);
		i++;
	}while(i < 2);
	console.log("Over");
</script>

首先，我们定义了一个最外层的 do while 循环嵌套，计数器 变量 i 从 0 开始，结束条件是 i

在最外层循环的里面，同时又定义了一个内部循环，计数器变量 j 从 0 开始，结束条件是 i

do while循环嵌套总结

JavaScript 的 do while 循环也可以实现嵌套的效果，即 do while 循环里面嵌套一个或多个 do while 循环。

【推荐学习：javascript高级教程】

Atas ialah kandungan terperinci Pembelajaran gelung JS: penggunaan pernyataan gelung sementara (contoh terperinci). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!