วนซ้ำ: ในขณะที่และสำหรับ

เรามักจะต้องทำซ้ำการกระทำ

ตัวอย่างเช่น ส่งออกสินค้าจากรายการทีละรายการ หรือเพียงเรียกใช้โค้ดเดียวกันสำหรับแต่ละหมายเลขตั้งแต่ 1 ถึง 10

ลูป เป็นวิธีหนึ่งในการทำซ้ำโค้ดเดียวกันหลายครั้ง

for...of และ for...in ลูป

ประกาศเล็กๆ น้อยๆ สำหรับผู้อ่านขั้นสูง

บทความนี้ครอบคลุมเฉพาะการวนซ้ำพื้นฐาน: while , do..while และ for(..;..;..)

หากคุณมาที่บทความนี้เพื่อค้นหาลูปประเภทอื่น นี่คือคำแนะนำ:

• ดูสำหรับ…ในเพื่อวนซ้ำคุณสมบัติของวัตถุ

• ดู for...of และ iterables สำหรับการวนซ้ำอาร์เรย์และอ็อบเจ็กต์ที่ทำซ้ำได้

มิฉะนั้นโปรดอ่านต่อ

ลูป "ในขณะที่"

while ลูปมีไวยากรณ์ดังต่อไปนี้:

 ในขณะที่ (เงื่อนไข) {
  // รหัส
  // เรียกว่า "ตัวห่วง"
-

แม้ว่า condition จะเป็นความจริง code จากเนื้อหาลูปก็จะถูกดำเนินการ

ตัวอย่างเช่น การวนซ้ำด้านล่างจะส่งออก i ในขณะที่ i < 3 :

 ให้ฉัน = 0;
ในขณะที่ (i < 3) { // แสดง 0 จากนั้น 1 และ 2
  การแจ้งเตือน (ฉัน);
  ฉัน++;
-

การดำเนินการครั้งเดียวของเนื้อความของลูปเรียกว่า การวนซ้ำ การวนซ้ำในตัวอย่างด้านบนจะวนซ้ำสามครั้ง

หาก i++ หายไปจากตัวอย่างด้านบน การวนซ้ำจะเกิดซ้ำ (ในทางทฤษฎี) ตลอดไป ในทางปฏิบัติ เบราว์เซอร์มีวิธีหยุดการวนซ้ำดังกล่าว และใน JavaScript ฝั่งเซิร์ฟเวอร์ เราสามารถปิดกระบวนการได้

นิพจน์หรือตัวแปรใดๆ ก็สามารถเป็นเงื่อนไขลูปได้ ไม่ใช่แค่การเปรียบเทียบเท่านั้น เงื่อนไขจะได้รับการประเมินและแปลงเป็นบูลีนด้วย while

ตัวอย่างเช่น วิธีเขียนที่สั้นกว่า while (i != 0) คือ while (i) :

 ให้ฉัน = 3;
ในขณะที่ (i) { // เมื่อฉันกลายเป็น 0 เงื่อนไขจะกลายเป็นเท็จ และการวนซ้ำจะหยุดลง
  การแจ้งเตือน (ฉัน);
  ฉัน--;
-

วงเล็บปีกกาไม่จำเป็นสำหรับเนื้อหาบรรทัดเดียว

หากเนื้อหาของลูปมีคำสั่งเดียว เราสามารถละเครื่องหมายปีกกา {…} :

 ให้ฉัน = 3;
ในขณะที่ (i) แจ้งเตือน (i--);

ลูป "ทำ... ในขณะที่"

การตรวจสอบเงื่อนไขสามารถย้ายไป อยู่ใต้ เนื้อหาลูปได้โดยใช้ไวยากรณ์ do..while :

 ทำ {
  // ห่วงร่างกาย
} ในขณะที่ (เงื่อนไข);

ลูปจะดำเนินการกับเนื้อหาก่อน จากนั้นจึงตรวจสอบเงื่อนไข และแม้ว่าจะเป็นจริง จะดำเนินการซ้ำแล้วซ้ำอีก

ตัวอย่างเช่น:

 ให้ฉัน = 0;
ทำ {
  การแจ้งเตือน (ฉัน);
  ฉัน++;
} ในขณะที่ (i < 3);

ควรใช้ไวยากรณ์รูปแบบนี้เฉพาะเมื่อคุณต้องการให้เนื้อหาของลูปดำเนินการ อย่างน้อยหนึ่งครั้ง โดยไม่คำนึงถึงเงื่อนไขที่เป็นความจริง โดยปกติแล้ว ควรใช้รูปแบบอื่น: while(…) {…}

วง "สำหรับ"

for loop นั้นซับซ้อนกว่า แต่ก็เป็น loop ที่ใช้บ่อยที่สุดเช่นกัน

ดูเหมือนว่านี้:

 สำหรับ (เริ่มต้น; เงื่อนไข; ขั้นตอน) {
  // ... ห่วงร่างกาย ...
-

มาเรียนรู้ความหมายของส่วนต่างๆ เหล่านี้ด้วยตัวอย่างกันดีกว่า ลูปด้านล่างเรียกใช้ alert(i) for i ตั้งแต่ 0 ถึง (แต่ไม่รวม) 3 :

 สำหรับ (ให้ i = 0; i <3; i++) { // แสดง 0 จากนั้น 1 จากนั้น 2
  การแจ้งเตือน (ฉัน);
-

เรามาตรวจสอบคำสั่ง for ทีละส่วนกัน:

อัลกอริธึมการวนซ้ำทั่วไปทำงานดังนี้:

 เริ่มวิ่ง
→ (หากเงื่อนไข → รันตัวถังและรันสเต็ป)
→ (หากเงื่อนไข → รันตัวถังและรันสเต็ป)
→ (หากเงื่อนไข → รันตัวถังและรันสเต็ป)
 ...

นั่นคือ begin ดำเนินการหนึ่งครั้ง จากนั้นทำซ้ำ: หลังจากการทดสอบ condition แต่ละครั้ง body และ step จะถูกดำเนินการ

หากคุณยังใหม่กับลูป การกลับไปที่ตัวอย่างและจำลองวิธีการวนซ้ำทีละขั้นตอนบนกระดาษอาจช่วยได้

นี่คือสิ่งที่เกิดขึ้นในกรณีของเรา:

 // สำหรับ (ให้ i = 0; i <3; i++) การแจ้งเตือน (i)

//เริ่มวิ่ง
ให้ฉัน = 0
// ถ้าเงื่อนไข → รันเนื้อหาและรันสเต็ป
ถ้า (i < 3) { การแจ้งเตือน (i); ฉัน++ }
// ถ้าเงื่อนไข → รันเนื้อหาและรันสเต็ป
ถ้า (i < 3) { การแจ้งเตือน (i); ฉัน++ }
// ถ้าเงื่อนไข → รันเนื้อหาและรันสเต็ป
ถ้า (i < 3) { การแจ้งเตือน (i); ฉัน++ }
// ...เสร็จสิ้น เพราะตอนนี้ i == 3

การประกาศตัวแปรแบบอินไลน์

ที่นี่ตัวแปร "ตัวนับ" i ได้รับการประกาศไว้ในลูปโดยตรง สิ่งนี้เรียกว่าการประกาศตัวแปรแบบอินไลน์ ตัวแปรดังกล่าวจะมองเห็นได้ภายในลูปเท่านั้น

 สำหรับ (ให้ i = 0; i <3; i++) {
  การแจ้งเตือน (ฉัน); // 0, 1, 2
-
การแจ้งเตือน (ฉัน); // ผิดพลาด ไม่มีตัวแปรดังกล่าว

แทนที่จะกำหนดตัวแปร เราสามารถใช้ตัวแปรที่มีอยู่ได้:

 ให้ฉัน = 0;

สำหรับ (i = 0; i < 3; i++) { // ใช้ตัวแปรที่มีอยู่
  การแจ้งเตือน (ฉัน); // 0, 1, 2
-

การแจ้งเตือน (ฉัน); // 3 มองเห็นได้ เนื่องจากประกาศไว้นอกลูป

ข้ามส่วน

ส่วนใดส่วนหนึ่งของ for สามารถข้ามได้

ตัวอย่างเช่น เราสามารถละเว้น begin ได้ ถ้าเราไม่จำเป็นต้องทำอะไรที่ loop start

ชอบที่นี่:

 ให้ฉัน = 0; // เราได้ประกาศและมอบหมายแล้ว

สำหรับ (; i < 3; i++) { // ไม่จำเป็นต้อง "เริ่มต้น"
  การแจ้งเตือน (ฉัน); // 0, 1, 2
-

นอกจากนี้เรายังสามารถลบส่วน step ออกได้:

 ให้ฉัน = 0;

สำหรับ (; ฉัน < 3;) {
  การแจ้งเตือน (i++);
-

สิ่งนี้ทำให้การวนซ้ำเหมือนกับ while (i < 3)

จริงๆ แล้วเราสามารถลบทุกอย่างออกได้ โดยสร้างวงวนที่ไม่มีที่สิ้นสุด:

 สำหรับ (;;) {
  // ทำซ้ำโดยไม่มีขีดจำกัด
-

โปรดทราบว่าทั้งสอง for อัฒภาค ; จะต้องมีอยู่ มิฉะนั้นจะเกิดข้อผิดพลาดทางไวยากรณ์

ทำลายวง

โดยปกติแล้ว ลูปจะออกเมื่อเงื่อนไขกลายเป็นเท็จ

แต่เราสามารถบังคับทางออกได้ตลอดเวลาโดยใช้คำสั่ง break พิเศษ

ตัวอย่างเช่น การวนซ้ำด้านล่างจะขอให้ผู้ใช้ระบุชุดตัวเลข โดยจะ "หมด" เมื่อไม่ได้ป้อนตัวเลข:

 ให้ผลรวม = 0;

ในขณะที่ (จริง) {

  ให้ค่า = +prompt("ป้อนตัวเลข", '');

  ถ้า (!value) แตก; -

  ผลรวม += ค่า;

-
alert( 'ผลรวม:' + ผลรวม );

คำสั่ง break จะเปิดใช้งานที่บรรทัด (*) หากผู้ใช้เข้าสู่บรรทัดว่างหรือยกเลิกการป้อนข้อมูล จะหยุดการวนซ้ำทันที โดยผ่านการควบคุมไปยังบรรทัดแรกหลังการวนซ้ำ กล่าวคือ alert .

การผสมผสาน “การวนซ้ำไม่สิ้นสุด + break ตามต้องการ” เหมาะอย่างยิ่งสำหรับสถานการณ์เมื่อต้องตรวจสอบเงื่อนไขของลูปไม่ใช่ที่จุดเริ่มต้นหรือจุดสิ้นสุดของลูป แต่อยู่ตรงกลางหรือแม้แต่ในหลายๆ ตำแหน่งของร่างกาย

ดำเนินการซ้ำครั้งต่อไป

คำสั่ง continue คือ "เวอร์ชันที่เบากว่า" ของ break มันไม่ได้หยุดวงทั้งหมด แต่จะหยุดการวนซ้ำปัจจุบันและบังคับให้ลูปเริ่มการวนซ้ำใหม่ (หากเงื่อนไขอนุญาต)

เราสามารถใช้มันได้หากเราทำซ้ำปัจจุบันเสร็จแล้ว และต้องการไปยังครั้งถัดไป

การวนซ้ำด้านล่างใช้ continue เพื่อส่งออกเฉพาะค่าคี่:

 สำหรับ (ให้ i = 0; i < 10; i++) {

  // ถ้าเป็นจริงให้ข้ามส่วนที่เหลือของร่างกายไป
  ถ้า (i % 2 == 0) ดำเนินการต่อ;

  การแจ้งเตือน (ฉัน); // 1 จากนั้น 3, 5, 7, 9
-

สำหรับค่าคู่ของ i คำสั่ง continue จะหยุดดำเนินการเนื้อความและผ่านการควบคุมไปยังการวนซ้ำครั้งถัดไปของ for (พร้อมกับตัวเลขถัดไป) ดังนั้น alert จึงถูกเรียกเฉพาะค่าคี่เท่านั้น

คำสั่ง continue ช่วยลดการซ้อน

การวนซ้ำที่แสดงค่าคี่อาจมีลักษณะดังนี้:

 สำหรับ (ให้ i = 0; i < 10; i++) {

  ถ้า (ฉัน % 2) {
    การแจ้งเตือน (ฉัน);
  -

-

จากมุมมองทางเทคนิค นี่จะเหมือนกับตัวอย่างด้านบน แน่นอนว่าเราสามารถรวมโค้ดไว้ในบล็อก if แทนที่จะใช้ continue

แต่เป็นผลข้างเคียง สิ่งนี้ทำให้เกิดการซ้อนขึ้นอีกระดับหนึ่ง (การเรียก alert ภายในเครื่องหมายปีกกา) หากโค้ดภายใน if ยาวเกินสองสามบรรทัด อาจทำให้การอ่านโดยรวมลดลง

ไม่ break/continue ไปทางด้านขวาของ '?'

โปรดทราบว่าโครงสร้างไวยากรณ์ที่ไม่ใช่นิพจน์ไม่สามารถใช้กับตัวดำเนินการแบบไตรภาคได้ ? - โดยเฉพาะอย่างยิ่ง ไม่อนุญาตให้ใช้คำสั่งเช่น break/continue

ตัวอย่างเช่น หากเราใช้รหัสนี้:

 ถ้า (ผม > 5) {
  การแจ้งเตือน (ฉัน);
} อื่น {
  ดำเนินการต่อ;
-

…และเขียนใหม่โดยใช้เครื่องหมายคำถาม:

 (ฉัน > 5) ? การแจ้งเตือน (i): ดำเนินการต่อ; // ไม่อนุญาตให้ดำเนินการต่อที่นี่

…มันหยุดทำงาน: มีข้อผิดพลาดทางไวยากรณ์

นี่เป็นอีกเหตุผลหนึ่งที่จะไม่ใช้ตัวดำเนินการเครื่องหมายคำถาม ? แทนที่จะเป็น if

ป้ายกำกับสำหรับหยุดพัก/ดำเนินการต่อ

บางครั้งเราจำเป็นต้องแยกออกจากลูปที่ซ้อนกันหลายอันพร้อมกัน

ตัวอย่างเช่น ในโค้ดด้านล่าง เราวนซ้ำ i และ j โดยแจ้งพิกัด (i, j) จาก (0,0) ถึง (2,2) :

 สำหรับ (ให้ i = 0; i <3; i++) {

  สำหรับ (ให้ j = 0; j <3; j++) {

    ให้ input = prompt(`ค่าที่ coords (${i},${j})`, '');

    // จะเป็นอย่างไรหากเราต้องการออกจากที่นี่ไปยัง Done (ด้านล่าง)?
  -
-

alert('เสร็จสิ้น!');

เราต้องการวิธีหยุดกระบวนการหากผู้ใช้ยกเลิกการป้อนข้อมูล

break ธรรมดาหลังจาก input จะทำให้วงในแตกเท่านั้น เท่านั้นยังไม่พอ – ฉลากมาช่วยชีวิต!

ป้ายกำกับ คือตัวระบุที่มีเครื่องหมายทวิภาคก่อนการวนซ้ำ:

 labelName: สำหรับ (...) {
  -
-

คำสั่ง break <labelName> ในลูปด้านล่างแยกออกเป็นป้ายกำกับ:

 ภายนอก: สำหรับ (ให้ i = 0; i < 3; i++) {

  สำหรับ (ให้ j = 0; j <3; j++) {

    ให้ input = prompt(`ค่าที่ coords (${i},${j})`, '');

    // หากเป็นสตริงว่างหรือถูกยกเลิก ให้แยกออกจากทั้งสองลูป
    ถ้า (!input) แตกด้านนอก; -

    //ทำอะไรสักอย่างที่มีค่า...
  -
-

alert('เสร็จสิ้น!');

ในโค้ดด้านบน break outer จะมองขึ้นไปด้านบนเพื่อหาป้ายกำกับที่ชื่อ outer และแยกออกจากวงนั้น

ดังนั้นการควบคุมจะไปตรงจาก (*) ถึง alert('Done!')

นอกจากนี้เรายังสามารถย้ายป้ายกำกับไปยังบรรทัดแยก:

 ภายนอก:
สำหรับ (ให้ i = 0; i < 3; i++) { ... }

คำสั่ง continue ยังสามารถใช้กับป้ายกำกับได้ ในกรณีนี้ การเรียกใช้โค้ดจะข้ามไปยังการวนซ้ำครั้งถัดไปของลูปที่มีป้ายกำกับ

ป้ายกำกับไม่อนุญาตให้ "กระโดด" ทุกที่

ป้ายกำกับไม่อนุญาตให้เราข้ามไปยังตำแหน่งที่ต้องการในโค้ด

ตัวอย่างเช่น เป็นไปไม่ได้ที่จะทำเช่นนี้:

 ทำลายฉลาก; // ข้ามไปที่ป้ายกำกับด้านล่าง (ใช้งานไม่ได้)

ป้ายกำกับ: สำหรับ (...)

คำสั่ง break จะต้องอยู่ภายในบล็อคโค้ด ในทางเทคนิคแล้ว บล็อกโค้ดที่มีป้ายกำกับใดๆ จะดำเนินการได้ เช่น:

 ฉลาก: {
  -
  ทำลายฉลาก; //ทำงาน
  -
-

…แม้ว่า 99.9% ของ break เวลาจะใช้ภายในลูป ดังที่เราได้เห็นในตัวอย่างด้านบน

continue สามารถทำได้จากภายในลูปเท่านั้น

สรุป

เราครอบคลุมลูป 3 ประเภท:

• while – มีการตรวจสอบเงื่อนไขก่อนการวนซ้ำแต่ละครั้ง

• do..while – เงื่อนไขจะถูกตรวจสอบหลังจากการวนซ้ำแต่ละครั้ง

• for (;;) – มีการตรวจสอบเงื่อนไขก่อนการวนซ้ำแต่ละครั้ง มีการตั้งค่าเพิ่มเติมให้เลือก

ในการสร้างลูปแบบ "ไม่มีที่สิ้นสุด" โดยปกติจะใช้โครงสร้าง while(true) การวนซ้ำดังกล่าวสามารถหยุดได้ด้วยคำสั่ง break

หากเราไม่ต้องการทำอะไรในการวนซ้ำปัจจุบันและต้องการส่งต่อไปยังครั้งถัดไป เราสามารถใช้คำสั่ง continue ได้

break/continue ป้ายกำกับการสนับสนุนก่อนการวนซ้ำ ป้ายกำกับเป็นวิธีเดียวที่จะ break/continue เพื่อออกจากลูปที่ซ้อนกันเพื่อไปยังลูปภายนอก

งาน

ค่าวงสุดท้าย

ความสำคัญ: 3

รหัสนี้แจ้งเตือนค่าสุดท้ายคืออะไร ทำไม

 ให้ฉัน = 3;

ในขณะที่ (i) {
  แจ้งเตือน( i-- );
-

สารละลาย

คำตอบ: 1 .

 ให้ฉัน = 3;

ในขณะที่ (i) {
  แจ้งเตือน( i-- );
-

การวนซ้ำทุกครั้งจะลดลง i 1 การตรวจสอบ while(i) หยุดการวนซ้ำเมื่อ i = 0

ดังนั้น ขั้นตอนของการวนซ้ำจึงเกิดลำดับต่อไปนี้ (“การวนซ้ำแบบคลี่ออก”):

 ให้ฉัน = 3;

การแจ้งเตือน(i--); // แสดง 3 ลด i เหลือ 2

alert(i--) // แสดง 2, ลด i เหลือ 1

alert(i--) // แสดง 1 ลด i เหลือ 0

// เสร็จแล้ว ในขณะที่ (i) การตรวจสอบหยุดการวนซ้ำ

while loop แสดงค่าใด

ความสำคัญ: 4

สำหรับการวนซ้ำทุกครั้ง ให้จดบันทึกค่าที่ส่งออก จากนั้นเปรียบเทียบกับค่าเฉลย

ทั้งสองลูป alert ค่าเดียวกันหรือไม่?

1. แบบฟอร์มคำนำหน้า ++i :

    ให้ฉัน = 0;
   ในขณะที่ (++ i < 5) แจ้งเตือน ( i );

2. รูปแบบ postfix i++

    ให้ฉัน = 0;
   ในขณะที่ (i ++ < 5) แจ้งเตือน ( i );

สารละลาย

งานนี้แสดงให้เห็นว่าแบบฟอร์ม postfix/prefix สามารถนำไปสู่ผลลัพธ์ที่แตกต่างกันได้อย่างไรเมื่อใช้ในการเปรียบเทียบ

1. ตั้งแต่ 1 ถึง 4

    ให้ฉัน = 0;
   ในขณะที่ (++ i < 5) แจ้งเตือน ( i );

   ค่าแรกคือ i = 1 เนื่องจาก ++i เพิ่มค่า i ก่อน จากนั้นจึงส่งคืนค่าใหม่ ดังนั้นการเปรียบเทียบครั้งแรกคือ 1 < 5 และ alert จะแสดง 1

   จากนั้นทำตาม 2, 3, 4… – ค่าต่างๆ จะปรากฏขึ้นทีละรายการ การเปรียบเทียบจะใช้ค่าที่เพิ่มขึ้นเสมอ เนื่องจาก ++ อยู่หน้าตัวแปร

   ในที่สุด i = 4 จะเพิ่มขึ้นเป็น 5 การเปรียบเทียบ while(5 < 5) ล้มเหลว และการวนซ้ำหยุด จึงไม่แสดง 5

2. ตั้งแต่ 1 ถึง 5

    ให้ฉัน = 0;
   ในขณะที่ (i ++ < 5) แจ้งเตือน ( i );

   ค่าแรกเป็นอีกครั้ง i = 1 รูปแบบ postfix ของ i++ ที่เพิ่มขึ้น i แล้วส่งคืนค่า เก่า ดังนั้นการเปรียบเทียบ i++ < 5 จะใช้ i = 0 (ตรงกันข้ามกับ ++i < 5 )

   แต่สาย alert จะแยกกัน เป็นอีกคำสั่งหนึ่งที่ดำเนินการหลังจากการเพิ่มขึ้นและการเปรียบเทียบ ดังนั้นจะได้กระแส i = 1

   จากนั้นทำตาม 2, 3, 4…

   หยุดที่ i = 4 กัน แบบฟอร์มคำนำหน้า ++i จะเพิ่มขึ้นและใช้ 5 ในการเปรียบเทียบ แต่ที่นี่เรามีแบบฟอร์ม postfix i++ ดังนั้นจึงเพิ่ม i เป็น 5 แต่ส่งคืนค่าเก่า ดังนั้นการเปรียบเทียบจึงเป็นจริง while(4 < 5) – จริง และการควบคุมจะดำเนินต่อไปเพื่อ alert

   ค่า i = 5 เป็นค่าสุดท้าย เนื่องจากในขั้นตอนถัดไป while(5 < 5) เป็นเท็จ

ค่าใดที่แสดงโดยลูป "for"

ความสำคัญ: 4

สำหรับแต่ละวง ให้เขียนว่าจะแสดงค่าใด แล้วเปรียบเทียบกับคำตอบ

ทั้งสองลูป alert ค่าเดียวกันหรือไม่?

1. แบบฟอร์ม postfix:

    สำหรับ (ให้ i = 0; i <5; i++) การแจ้งเตือน ( i );

2. แบบฟอร์มคำนำหน้า:

    สำหรับ (ให้ i = 0; i < 5; ++ i) การแจ้งเตือน ( i );

สารละลาย

คำตอบ: จาก 0 ถึง 4 ในทั้งสองกรณี

 สำหรับ (ให้ i = 0; i < 5; ++ i) การแจ้งเตือน ( i );

สำหรับ (ให้ i = 0; i <5; i++) การแจ้งเตือน ( i );

ที่สามารถหักออกจากอัลกอริทึมของ for :

1. ดำเนินการหนึ่งครั้ง i = 0 ก่อนทุกอย่าง (เริ่มต้น)

2. ตรวจสอบสภาพ i < 5

3. หากเป็น true - ดำเนินการ alert(i) จากนั้น i++

การเพิ่มขึ้น i++ ถูกแยกออกจากการตรวจสอบเงื่อนไข (2) นั่นเป็นเพียงคำสั่งอื่น

ค่าที่ส่งคืนตามส่วนเพิ่มไม่ได้ใช้ที่นี่ ดังนั้นจึงไม่มีความแตกต่างระหว่าง i++ และ ++i

ส่งออกเลขคู่ในลูป

ความสำคัญ: 5

ใช้ for loop เพื่อส่งออกเลขคู่ตั้งแต่ 2 ถึง 10

เรียกใช้การสาธิต

สารละลาย

 สำหรับ (ให้ i = 2; i <= 10; i++) {
  ถ้า (ฉัน % 2 == 0) {
    การแจ้งเตือน (ฉัน);
  -
-

เราใช้ตัวดำเนินการ "โมดูโล" % เพื่อรับส่วนที่เหลือและตรวจสอบความสม่ำเสมอที่นี่

แทนที่ "สำหรับ" ด้วย "ในขณะที่"

ความสำคัญ: 5

เขียนโค้ดใหม่โดยเปลี่ยน for loop เป็น while โดยไม่เปลี่ยนแปลงพฤติกรรม (เอาต์พุตควรคงเดิม)

 สำหรับ (ให้ i = 0; i <3; i++) {
  alert( `หมายเลข ${i}!` );
-

สารละลาย

 ให้ฉัน = 0;
ในขณะที่ (ฉัน < 3) {
  alert( `หมายเลข ${i}!` );
  ฉัน++;
-

ทำซ้ำจนกว่าอินพุตจะถูกต้อง

ความสำคัญ: 5

เขียนลูปโดยให้ใส่ตัวเลขที่มากกว่า 100 หากผู้เยี่ยมชมป้อนหมายเลขอื่น – ขอให้พวกเขาป้อนอีกครั้ง

การวนซ้ำจะต้องขอตัวเลขจนกว่าผู้เข้าชมจะป้อนตัวเลขที่มากกว่า 100 หรือยกเลิกการป้อนข้อมูล/เข้าสู่บรรทัดว่าง

ที่นี่เราสามารถสรุปได้ว่าผู้เยี่ยมชมป้อนเฉพาะตัวเลขเท่านั้น ไม่จำเป็นต้องมีการจัดการพิเศษสำหรับอินพุตที่ไม่ใช่ตัวเลขในงานนี้

เรียกใช้การสาธิต

สารละลาย

 ให้หมายเลข;

ทำ {
  num = prompt("กรอกตัวเลขที่มากกว่า 100?", 0);
} ในขณะที่ (num <= 100 && num);

การวนซ้ำ do..while ที่ทำซ้ำในขณะที่การตรวจสอบทั้งสองเป็นความจริง:

1. การตรวจสอบ num <= 100 – นั่นคือค่าที่ป้อนยังคงไม่เกิน 100

2. เครื่องหมาย && num เป็นเท็จ เมื่อ num เป็น null หรือสตริงว่าง จากนั้น while ลูปก็หยุดเช่นกัน

PS หาก num เป็น null ดังนั้น num <= 100 จะเป็น true ดังนั้นหากไม่มีการตรวจสอบครั้งที่ 2 การวนซ้ำจะไม่หยุดหากผู้ใช้คลิก CANCEL จำเป็นต้องมีการตรวจสอบทั้งสองอย่าง

เอาท์พุทจำนวนเฉพาะ

ความสำคัญ: 3

จำนวนเต็มที่มากกว่า 1 เรียกว่าจำนวนเฉพาะ หากไม่สามารถหารด้วยสิ่งใดสิ่งหนึ่งได้โดยไม่มีเศษเหลือ ยกเว้น 1 และตัวมันเอง

กล่าวอีกนัยหนึ่ง n > 1 เป็นจำนวนเฉพาะหากไม่สามารถหารด้วยสิ่งใดๆ ได้เท่าๆ กัน ยกเว้น 1 และ n

ตัวอย่างเช่น 5 เป็นจำนวนเฉพาะ เนื่องจากไม่สามารถหารโดยไม่มีเศษด้วย 2 , 3 และ 4 ได้

เขียนโค้ดที่ให้ผลลัพธ์เป็นตัวเลขเฉพาะในช่วงตั้งแต่ 2 ถึง n

สำหรับ n = 10 ผลลัพธ์จะเป็น 2,3,5,7

PS รหัสควรใช้งานได้กับ n ใด ๆ ไม่ได้รับการปรับแต่งอย่างหนักสำหรับค่าคงที่ใด ๆ

สารละลาย

มีอัลกอริธึมมากมายสำหรับงานนี้

ลองใช้ลูปแบบซ้อน:

 สำหรับแต่ละ i ในช่วงเวลา {
  ตรวจสอบว่าฉันมีตัวหารจาก 1..i หรือไม่
  ถ้าใช่ => ค่าไม่ใช่จำนวนเฉพาะ
  ถ้าไม่ใช่ => ค่านั้นเป็นจำนวนเฉพาะ ให้แสดงมัน
-

รหัสที่ใช้ป้ายกำกับ:

 ให้ n = 10;

ต่อไปนายกรัฐมนตรี:
สำหรับ (ให้ i = 2; i <= n; i++) { // สำหรับแต่ละ i...

  for (ให้ j = 2; j < i; j++) { // มองหาตัวหาร..
    ถ้า (i % j == 0) ดำเนินการต่อถัดไปนายกรัฐมนตรี; // ไม่ใช่จำนวนเฉพาะ ไปต่อไป i
  -

  การแจ้งเตือน (ฉัน); // ไพรม์
-

มีพื้นที่มากมายในการเพิ่มประสิทธิภาพ เช่น เราอาจหาตัวหารตั้งแต่ 2 ถึงรากที่สองของ i แต่อย่างไรก็ตาม หากเราต้องการมีประสิทธิภาพจริงๆ เป็นระยะเวลานาน เราจำเป็นต้องเปลี่ยนวิธีการและอาศัยคณิตศาสตร์ขั้นสูงและอัลกอริธึมที่ซับซ้อน เช่น ตะแกรงกำลังสอง ตะแกรงฟิลด์ตัวเลขทั่วไป เป็นต้น