การวนซ้ำคือการทำสิ่งหนึ่งซ้ำๆ กัน ในกระบวนการเขียนโค้ด เรามักจะพบกับการดำเนินการบางอย่างที่จำเป็นต้องดำเนินการซ้ำๆ เช่น การข้ามข้อมูลบางอย่าง การเอาท์พุตสตริงบางอย่างซ้ำๆ เป็นต้น การเขียนบรรทัดจะยุ่งยากเกินไป โดย line สำหรับการทำซ้ำแบบนี้เราควรเลือกใช้การวนซ้ำเพื่อทำให้เสร็จสิ้น
วัตถุประสงค์ของการวนซ้ำคือการรันโค้ดบางชิ้นซ้ำๆ การใช้ลูปสามารถลดความกดดันในการเขียนโปรแกรม หลีกเลี่ยงความซ้ำซ้อนของโค้ด ปรับปรุงประสิทธิภาพการพัฒนา และอำนวยความสะดวกในการบำรุงรักษาในภายหลัง while loop เป็นคำสั่งลูปที่ง่ายที่สุดที่มีให้ใน JavaScript มาเรียนรู้เกี่ยวกับการใช้ while loop และ do- While loop
คำสั่ง while นั้นเป็นคำสั่ง loop当型เงื่อนไขของ loop จะถูกตัดสินก่อน เมื่อตรงตามเงื่อนไข เนื้อหาของ loop จะถูกดำเนินการ หากไม่พอใจก็หยุด
ฟังก์ชั่น: ทำซ้ำการดำเนินการจนกว่าจะไม่ตรงตามเงื่อนไขที่ระบุ
คุณสมบัติ: ขั้นแรกให้ตัดสินนิพจน์ และดำเนินการคำสั่งที่เกี่ยวข้องเมื่อผลลัพธ์ของนิพจน์เป็นจริง
1. js ในขณะที่วนไวยากรณ์
ในขณะที่ (นิพจน์) {// นิพจน์คือเงื่อนไขลูป // รหัสที่จะดำเนินการ} การวิเคราะห์คำสั่ง:
แรกคำนวณค่าของ "นิพจน์" เมื่อค่าเป็นจริงให้ดำเนินการ "php" ในลูป body Statement block";
คำอธิบาย: ผลการคำนวณของ "นิพจน์" จะเป็นประเภท Boolean (TRUE หรือ FALSE) หากเป็นค่าประเภทอื่นก็จะถูกแปลงเป็นค่าประเภท Boolean โดยอัตโนมัติ (เนื่องจาก PHP เป็นภาษาที่อ่อนแอ และจะถูกแปลงตามค่าของตัวแปร โดยจะแปลงตัวแปรให้เป็นประเภทข้อมูลที่ถูกต้องโดยอัตโนมัติ)
"statement block" คือชุดของคำสั่งตั้งแต่หนึ่งคำสั่งขึ้นไปที่ล้อมรอบด้วย
{ }; หากมีเพียงหนึ่งคำสั่งใน block ก็สามารถละเว้น{ }ได้
หลังจากดำเนินการเสร็จสิ้น ให้กลับไปที่นิพจน์และคำนวณค่าของนิพจน์อีกครั้งเพื่อตัดสิน เมื่อค่านิพจน์เป็นจริง ให้ดำเนินการ "บล็อกคำสั่ง" ต่อไป... กระบวนการนี้จะถูกทำซ้ำ
จนกระทั่งค่าของนิพจน์ เป็นเท็จก่อนที่จะกระโดดออกจากลูป ให้ดำเนินการคำสั่งด้านล่างในขณะที่
แผนภูมิการไหลของคำสั่ง while มีดังนี้:
โดยปกติแล้ว "นิพจน์" จะเป็นค่าที่คำนวณโดยใช้ตัวดำเนินการเปรียบเทียบหรือตัวดำเนินการเชิงตรรกะ
โค้ดตัวอย่างจะเป็นดังนี้:
<script>
วาร์ i = 1;
ในขณะที่ (ฉัน <= 5) {
document.write(i+", ");
ฉัน++;
-
</สคริปต์> 
หมายเหตุ:
เมื่อเขียนคำสั่งลูป คุณต้องแน่ใจว่าผลลัพธ์ของนิพจน์เงื่อนไขสามารถเป็นเท็จได้ (นั่นคือ ค่าบูลีน เท็จ) เพราะตราบใดที่ผลลัพธ์ของนิพจน์เป็นจริง การวนซ้ำจะดำเนินต่อไปและจะไม่ หยุดโดยอัตโนมัติ สำหรับความล้มเหลวประเภทนี้ การวนซ้ำที่หยุดโดยอัตโนมัติมักเรียกว่า "การวนซ้ำไม่สิ้นสุด" หรือ "การวนซ้ำไม่สิ้นสุด"
หากคุณสร้างวงวนไม่สิ้นสุดโดยไม่ได้ตั้งใจ อาจทำให้เบราว์เซอร์หรือคอมพิวเตอร์ค้าง
หากนิพจน์เป็นจริงเสมอและเงื่อนไขการวนซ้ำเป็นจริงเสมอ การวนซ้ำ while จะดำเนินการต่อไปและไม่มีวันสิ้นสุด กลายเป็น "การวนซ้ำไม่สิ้นสุด"
var i = 1;
ในขณะที่(ฉัน){
console.log(i);
} หลังจากรันโปรแกรมแล้ว ค่าของตัวแปร i จะถูกส่งออกจนกว่าผู้ใช้จะบังคับให้ปิด
JS while loop example
[ตัวอย่างที่ 1] ใช้ while loop เพื่อคำนวณผลรวมของจำนวนเต็มทั้งหมดระหว่าง 1 ถึง 100:
<script>
วาร์ i = 1;
ผลรวม var=0;
ในขณะที่(i<=100){
ผลรวม+=ฉัน;
ฉัน++;
-
console.log("ค่าของ 1 บวกกับ 100 คือ: "+sum);
</script> ผลลัพธ์ที่ได้:
[ตัวอย่างที่ 2] ค้นหาปีอธิกสุรทินทั้งหมดระหว่างปี 1900 ถึง 2020 และส่งออกเป็น 6 ต่อบรรทัด:
<script>
วาร์ i = 1900;
var count = 0; //นับจำนวนปีอธิกสุรทินในขณะที่ (i <= 2020) {
// พิจารณาว่าเป็นปีอธิกสุรทินหรือไม่ถ้า (i % 4 == 0 && i % 100 != 0 || i % 400 == 0) {
document.write(i + " ");
นับ++;
ถ้า (นับ % 6 == 0) {
document.write("<br/>");
-
-
ฉัน++;
-
</สคริปต์> 
2. JS ในขณะที่โครงสร้างที่ซ้อนกันแบบวนซ้ำ
ในขณะที่การวนซ้ำยังสามารถบรรลุเอฟเฟกต์การซ้อนได้ นั่นคือ อย่างน้อยหนึ่งในขณะที่วนซ้ำซ้อนอยู่ภายในในขณะที่วนซ้ำ
รูปแบบไวยากรณ์:
while(เงื่อนไข 1){
// โค้ดจะดำเนินการเมื่อเงื่อนไข 1 เป็นจริง ในขณะที่ (เงื่อนไข 2) {
// โค้ดจะดำเนินการเมื่อเงื่อนไข 2 เป็นจริง...
-
} สรุป: การซ้อนหมายถึงการรวม สิ่งที่เรียกว่าการซ้อนแบบ while คือการซ้อนแบบ while แต่ละครั้งจะเหมือนกับไวยากรณ์พื้นฐานก่อนหน้านี้
ที่นี่ เรากำหนดการซ้อน while ของสองลูป แน่นอนว่าเราสามารถซ้อน while ลูปได้มากเท่าที่ต้องการ
ทำความเข้าใจกระบวนการดำเนินการ while loop
หลังจากดำเนินการ loop ภายในเสร็จสิ้น การพิจารณาเงื่อนไขของ loop ภายนอกถัดไปจะถูกดำเนินการ
ตัวอย่างที่ 1: การใช้ลูปที่ซ้อนกัน พิมพ์ตัวนับ
<script type="text/javascript">
วาร์ i = 0;
ในขณะที่(ฉัน < 2){
console.log("i =", i);
วาร์ เจ = 0;
ในขณะที่(เจ < 2){
console.log("tj =", เจ);
เจ += 1;
-
ฉัน++;
-
console.log("เกิน");
</สคริปต์> 
ขั้นแรก เรากำหนดส่วนนอกสุดในขณะที่วนซ้ำ ตัวแปรตัวนับ i เริ่มจาก 0 และเงื่อนไขสิ้นสุดคือ i < 2 แต่ละครั้งที่ดำเนินการวนซ้ำ ค่าของ i จะเพิ่มขึ้น 1 และค่าปัจจุบันของ i จะถูกพิมพ์
ภายในลูปด้านนอกสุด ตัวแปรตัวนับ j เริ่มจาก 0 และเงื่อนไขสิ้นสุดคือ i < 2 แต่ละครั้งที่ดำเนินการลูป ค่าของ j จะเพิ่มขึ้น 1 และค่าปัจจุบันของ J ถูกพิมพ์
สรุปการวนซ้ำ while ที่ซ้อนกัน
ของ JavaScript ในขณะที่การวนซ้ำยังสามารถบรรลุผลแบบซ้อน กล่าวคือ อย่างน้อยหนึ่ง while วนซ้ำซ้อนอยู่ภายใน while loop
ตัวอย่างที่ 2:
<สคริปต์>
-
1. พิมพ์ลูกสะใภ้ 3 ครั้งในลูปฉันผิด 2. ล้างจาน 3. ข้างต้นเป็นชุดของการลงโทษชุดการลงโทษนี้ซ้ำเป็นเวลา 3 วัน -ชุดการลงโทษจะต้องทำซ้ำ - วางไว้ใน while loop */
var j = 0
ในขณะที่(เจ < 3){
var i = 0
ในขณะที่(ฉัน < 3){
document.write('ลูกสะใภ้ ฉันผิดไปแล้ว<br>')
ฉัน += 1;
-
document.write('ล้างจาน<br>')
Document.write ('การลงโทษหนึ่งชุดจบลงแล้ว !!!!!!!!!!!!! <br>')
เจ += 1;
-
</สคริปต์> 
นอกจากการวนซ้ำ while แล้ว ยังมีการวนซ้ำ do- While อีกด้วย
คำสั่ง do-直到型loop คือคำสั่ง loop ขั้นแรกจะดำเนินการ "statement block" ในส่วนเนื้อหาของ loop หนึ่งครั้ง จากนั้นจึงตัดสินเงื่อนไขของ loop หากเป็นจริง ก็จะวนซ้ำต่อไป , , การวนซ้ำถูกยกเลิก
ดังนั้น: ไม่ว่าผลลัพธ์ของนิพจน์จะเป็นอย่างไร คำสั่ง do- While loop จะดำเนินการ "statement block" อย่างน้อยหนึ่งครั้ง
คุณลักษณะของคำสั่ง do- While loop: ดำเนินการกับเนื้อความของลูปก่อน จากนั้นจึงพิจารณาว่าเงื่อนไขของลูปเป็นจริงหรือไม่
1. JS ทำในขณะที่ไวยากรณ์วนซ้ำ
ทำ {
บล็อกคำสั่ง;
} while(expression);//นิพจน์ถูก แยกวิเคราะห์เป็นคำสั่งแบบมีเงื่อนไขแบบวนซ้ำ:
ขั้นแรกให้ดำเนินการ "บล็อกคำสั่ง" ในส่วนเนื้อหาของลูป จากนั้นกำหนดค่าของ "นิพจน์" เมื่อค่าของ "นิพจน์" เป็นจริง ให้กลับไปดำเนินการบล็อกคำสั่งในส่วนเนื้อหาของลูปอีกครั้ง... กระบวนการนี้จะถูกทำซ้ำ
จนกระทั่งนิพจน์ เมื่อค่าของสูตรเป็นเท็จ ให้ข้ามออกจากลูป ในเวลานี้ การวนซ้ำจะสิ้นสุดลงและคำสั่งที่ตามมาจะถูกดำเนินการ
หมายเหตุ:
เช่นเดียวกับลูป while ผลลัพธ์การคำนวณของ "นิพจน์" ในลูป do- While ต้องเป็นค่าบูลีน TRUE หรือ FALSE หากเป็นค่าประเภทอื่น ค่านั้นจะถูกแปลงเป็นค่าบูลีนโดยอัตโนมัติ
เซมิโคลอนในตอนท้ายของคำสั่งทำในขณะที่ไม่สามารถละเว้นได้ (ต้องมีอยู่ ;
แผนภูมิการไหลของคำสั่งวนซ้ำในขณะที่มีดังนี้:
js do-do-while loop ตัวอย่าง
[ตัวอย่างที่ 1] ใช้ทำในขณะที่หมายเลขเอาต์พุต 1 ~ 5:
<script>
วาร์ i = 1;
ทำ {
document.write(i+", ");
ฉัน++;
}ในขณะที่( ฉัน <= 5);
</สคริปต์> 
[ตัวอย่างที่ 2] ใช้ในขณะที่ลูปเพื่อคำนวณผลรวมของจำนวนเต็มทั้งหมดระหว่าง 1 ถึง 100:
<script>
วาร์ i = 1;
ผลรวม var=0;
ทำ{
sum+= i;
ฉัน++;
} ในขณะที่ (i <= 100);
console.log ("1 + 2 + 3 + ... + 98 + 99 + 100 =" + ผลรวม);
</สคริปต์> 
[ตัวอย่างที่ 3] ค้นหาทุกปีระหว่างปี 1900 ถึง 2020
<Repcrid>
var i = 1900;
count var = 0;
// พิจารณาว่าเป็นปีอธิกสุรทินหรือไม่ถ้า (i % 4 == 0 && i % 100 != 0 || i % 400 == 0) {
console.log(i);
-
ฉัน++;
} ในขณะที่ (ฉัน <= 2020);
</สคริปต์> 
2. โครงสร้างแบบซ้อน do- while ของ JS
do while ยังสามารถบรรลุเอฟเฟกต์การซ้อนได้ นั่นคือ do while อย่างน้อยหนึ่งลูปซ้อนอยู่ภายใน do while loop วิธีการเขียนนี้คล้ายกับการซ้อนกันของ while loop
ไวยากรณ์:
ทำ {
// คำสั่งบล็อก 1;
ทำ{
// บล็อกคำสั่ง 2;
ทำ{
// บล็อกคำสั่ง 2;
-
} ในขณะที่ (เงื่อนไข 3);
} ในขณะที่ (เงื่อนไข 2);
} while(Condition 1); ในที่นี้ เราได้กำหนด do while loops สามอัน แน่นอนว่าเราสามารถซ้อน do while loop ได้มากเท่าที่ต้องการ
กรณี: ใช้การซ้อนแบบวนซ้ำเพื่อพิมพ์ตัวนับ
<script type="text/javascript">
วาร์ i = 0;
ทำ{
console.log ("i =", i);
วาร์ เจ = 0;
ทำ{
console.log (" tj =", j);
j += 1;
} ในขณะที่ (j <2);
ฉัน++;
} ในขณะที่ (i <2);
console.log ("over");
</สคริปต์> 
ขั้นแรก เรากำหนดคำสั่ง do while วงนอกสุด ตัวแปรตัวนับ i เริ่มจาก 0 และเงื่อนไขสิ้นสุดคือ i < 2 แต่ละครั้งที่ดำเนินการวนซ้ำ ค่าของ i จะเพิ่มขึ้น 1 และค่าปัจจุบันของ ฉันจะพิมพ์
ภายในวงรอบนอกสุดจะมีการกำหนดลูปด้านในด้วยเช่นกัน J ถูกพิมพ์
บทสรุปของการทำในขณะที่ลูปทำรัง
จาวาสคริปต์ในขณะที่ลูปยังสามารถบรรลุเอฟเฟกต์ที่ซ้อนกันนั่นคือหนึ่งหรือมากกว่านั้นในขณะที่ลูปจะซ้อนอยู่ใน A DO ในขณะลูป
[การเรียนรู้ที่แนะนำ: บทช่วยสอนขั้นสูง JavaScript]
ด้านบนคือเนื้อหาโดยละเอียดของการเรียนรู้ JS loop: การใช้คำสั่ง while loop (ตัวอย่างโดยละเอียด) สำหรับข้อมูลเพิ่มเติม โปรดใส่ใจกับบทความอื่น ๆ ที่เกี่ยวข้องบนเว็บไซต์ PHP Chinese!
