สวัสดีและยินดีต้อนรับกลับ
ยังคงจะพูดถึงเล็กน้อยเกี่ยวกับการควบคุมโฟลว์
เลยมาดูการวนซ้ำของโค้ดกัน
อันดับแรก เราจะพูดถึงเรื่องนี้สำหรับลูป
for loop จะเป็นการทำซ้ำโค้ดทั้งหมด
เพื่อเป็นการเตือนความจำว่า
การทำซ้ำโค้ดเป็นวิธีที่ไม่ให้เกิดการซ้ำซ้อน และจริงๆ
แล้วคุณอาจรันโค้ดที่เหมือนกันมากกว่าหนึ่งตัวในแต่ละครั้ง
ดังนั้นภาษาการเขียนโปรแกรม c จึงมีโครงสร้างบางอย่างที่ออกแบบมาสำหรับภาษาที่คุณสามารถใช้ได้เมื่อต้องการทำซ้ำโค้ด
และสิ่งนี้ทำให้คุณสามารถทำซ้ำกลุ่มคำสั่งได้จนกว่าจะตรงตามเงื่อนไขบางอย่าง
ดังนั้นมันจึงคล้ายกับ for loop และคุณจะประเมินนิพจน์บูลีน
ซึ่งเป็นเงื่อนไข คุณไม่สามารถวิ่งได้ตลอดไป
เมื่อคุณรันในลูปตลอดไป นั่นหมายความว่ามันเป็นลูปอนันต์
และมีบางช่วงเท่านั้นที่คุณอาจต้องการทำแบบนั้นอีกครั้ง
เช่น การเฝ้าติดตามหรือฟังอะไรบางอย่าง
ดังนั้นจำนวนครั้งที่วนซ้ำจึงสามารถควบคุมได้ง่ายๆ โดยบัญชี
มี 2 ประเภทของการวนซ้ำที่คุณสามารถทำได้
ลูปคอนโทรลเคาน์เตอร์ หรือลูปคอนโทรลแบบเซนติเนลคือสิ่งที่พวกเขาเรียกมันว่า
ลูปควบคุมเคาน์เตอร์หมายความว่าลูปรัน
10 ครั้ง 20 ครั้ง 30 ครั้งในระยะเวลาที่กำหนด
มันทำซ้ำบล็อกคำสั่งเดียวกันภายในวนซ้ำหลายครั้ง
คุณสามารถมีลูปประเภทอื่นที่ไม่ได้ควบคุมได้
อาจรัน 5 ครั้ง อาจรัน 100 อาจต้องการ 20 ทั้งหมดขึ้นอยู่กับเงื่อนไข
ตัวแปร หรือบางสิ่งบางอย่าง ตัวอย่างเช่น คุณสามารถเรียกใช้ลูปที่ระบุว่าฉันจะเรียกใช้ลูปซ้ำแล้วซ้ำอีกจนกว่าผู้ใช้จะเข้าสู่
quit
จนกว่าตัวแปรจะเปลี่ยนเป็นออก มันไม่ได้ถูกควบคุมโดยเคาน์เตอร์ มันไม่ได้ขึ้นอยู่กับ
อีกครั้งอาจวิ่ง 10 ครั้ง อาจวิ่ง 100 ครั้ง
นี่คือ 2 ประเภทของลูปที่แตกต่างกัน ดังนั้นฉันจะยกตัวอย่างของทั้งสองอย่าง
แต่ลองคิดดูในระดับสูงว่าเมื่อใดที่ฉันต้องการทำซ้ำโค้ด
ฉันอาจต้องการทำซ้ำรหัส 5 ครั้ง ระยะเวลาหนึ่ง ระยะเวลาที่แน่นอน
หรือฉันอาจต้องการใส่รหัสตามเงื่อนไขบางอย่างที่ผู้ใช้ป้อน
ซึ่งเรียกว่าผู้พิทักษ์
for loop ของเรามี for คีย์เวิร์ด ใช้เพื่อดำเนินการตามจำนวนที่กำหนด
มักใช้สำหรับการควบคุมเคาน์เตอร์ แต่ไม่จำเป็นต้องเป็นเช่นนั้น
คุณสามารถใช้มันสำหรับลูปควบคุมเคาน์เตอร์หรือยามเพื่อควบคุมลูป
มันขึ้นอยู่กับคุณ. แต่ตัวอย่างมากมายในการฝึกฝนส่วนใหญ่นั้นถูกควบคุมโดยตอบโต้ในบางครั้ง
หากคุณต้องการแสดงตัวเลขตั้งแต่ 1 ถึง 10 คุณจะต้องใช้ for loop
คุณคงไม่อยากเขียนโค้ด 10 บรรทัดด้วยคำสั่ง
printf เดียวกันในนั้นโดยแสดงตัวเลขต่างกัน
นั่นไม่มีประสิทธิภาพมาก มันใช้เวลานานมาก
คุณจะใช้ for loop เพื่อทำซ้ำโค้ด
สิ่งที่คุณจะทำคือคุณจะทำอะไรแบบนี้
ต่อไปนี้คือข้อมูลเบื้องต้นว่า for loop มีลักษณะอย่างไร
ไวยากรณ์
คุณมีคีย์เวิร์ด for แล้วคุณมีวงเล็บเหล่านี้
อีกครั้ง วงเล็บระบุสิ่งต่าง ๆ ที่เกิดขึ้นสำหรับลูป
จากนั้นคุณมีวงเล็บและคุณมีคำสั่งในวงเล็บ
ดังนั้น อีกครั้ง วงเล็บแสดงถึงเนื้อความของลูป เช่นเดียวกับวงเล็บที่แสดงถึงเนื้อความของคำสั่ง
if
หากคุณมีประโยคคำสั่งเดียวในนั้น คุณไม่จำเป็นต้องมีวงเล็บ
แต่ควรนำไปใช้เสมอ
ในตัวอย่างนี้ คุณจะเห็นคำว่า for key word ซึ่งควรเป็นสิ่งแรกที่คุณระบุ
การดำเนินการ ระยะเวลาที่จะรันจะถูกควบคุม และสิ่งที่ปรากฏระหว่างวงเล็บหลัง
for คีย์เวิร์ด ซึ่งเราจะพูดถึงรายละเอียดเฉพาะ
ข้างในนั้นมีนิพจน์ที่แตกต่างกัน 3 แบบ
และคุณสามารถจำพวกมันได้เพราะคั่นด้วยเครื่องหมายอัฒภาค
อัฒภาคบอกว่านี่คือคำสั่งนิพจน์
3 สิ่งนั้นกำลังทำอะไรอยู่ เราจะมาอธิบายกัน
การกระทำที่คุณต้องการทำซ้ำนั้นอยู่ภายในเนื้อหาของลูป
นั่นคือสิ่งที่เกิดขึ้นหลายครั้ง
ในตัวอย่างนี้ เนื้อหาของลูปคือ printf
ดังนั้นหากเงื่อนไขได้รับการประเมินว่าเป็นจริง ก็จะพิมพ์ตัวเลขนั้นต่อไป
และอีกครั้ง สำหรับข้อความเดียว คุณสามารถละเว้นวงเล็บปีกกา
มาดูรายละเอียดในนี้กัน
รูปแบบทั่วไปของ for loop คือคุณมีคำสั่งประเภทนี้
คุณมี for แล้วคุณมีเงื่อนไขเริ่มต้น นี่คือ pseudocode
ฉันกำลังพยายามอธิบาย for loop ที่นี่
ดังนั้นเงื่อนไขเริ่มต้นคือสิ่งแรก ทุกอย่างก่อนเครื่องหมายอัฒภาคแรก
สิ่งที่สองคือเงื่อนไขความต่อเนื่องโดยมีเครื่องหมายอัฒภาคต่อท้าย
และสิ่งสุดท้ายที่อยู่ระหว่างวงเล็บคือการกระทำต่อการวนซ้ำ
และฉันต้องการอธิบายแต่ละข้อเหล่านี้ และหลังจากนั้นภายในร่างกายก็มีคำสั่งวนซ้ำ
คำสั่งวนซ้ำนั้นค่อนข้างง่าย ที่อยู่ภายในร่างกายเท่านั้น
นั่นคือรหัสที่จะดำเนินการซ้ำในแต่ละครั้ง
นั่นค่อนข้างพื้นฐาน
และอีกครั้ง คุณสามารถมีวงเล็บปีกกาได้ถ้าคุณมีหลายคำสั่งหรือละเว้นวงเล็บถ้าคุณมีคำสั่งเดียว
เงื่อนไขเริ่มต้น สิ่งแรกในวงเล็บก่อนเครื่องหมายอัฒภาคแรกมักจะเป็นแต่ไม่เสมอไปที่จะเริ่มต้นตัวแปร
เรียกว่าตัวแปรควบคุมลูป
นั่นคือตัวแปรที่คุณจะเริ่มดูการวนซ้ำแต่ละครั้ง
ดังนั้นโดยทั่วไปตัวแปรควบคุมลูปจึงเป็นตัวนับในบางครั้ง ไม่ใช่อีกครั้ง
ฉันต้องการเน้นว่า ไม่จำเป็นต้องเป็นเช่นนั้น
แต่หลายครั้งใน
for loop มันเป็นตัวนับ และติดตามว่ามีการวนซ้ำบ่อยแค่ไหน
นั่นคือสิ่งที่เงื่อนไขเริ่มต้นและตัวแปรควบคุมลูปกำลังทำอยู่
คุณยังสามารถประกาศและเริ่มต้นตัวแปรหลายตัวที่เป็นประเภทเดียวกันได้ที่นี่ด้วยการประกาศคั่นด้วยเครื่องหมายจุลภาค
ดังนั้นคุณสามารถมีตัวแปรเริ่มต้นได้หลายตัวที่นี่
ขึ้นอยู่กับสิ่งที่คุณใช้คอมไพเลอร์ c คุณอาจไม่สามารถประกาศตัวแปรเหล่านั้นภายในคำสั่ง
for
ถ้าคุณใช้อะไรก็ตามที่อยู่ต่ำกว่าคอมไพเลอร์ C99 คุณต้องประกาศตัวแปรนอกคำสั่ง
for จากนั้นคุณก็แค่เริ่มต้นพวกมันในที่นี้โดยที่เงื่อนไขเริ่มต้นระบุไว้ แต่เราจะพูดถึงตัวอย่างเหล่านั้น
แต่เงื่อนไขเริ่มต้นคือตำแหน่งที่คุณเริ่มต้นตัวแปร
เป็นตัวแปรควบคุมลูปและตั้งชื่อตามเหตุผลนั้นเพราะควบคุมความถี่ที่ลูปจะดำเนินการเมื่อคุณเริ่มต้น
สิ่งต่อไปที่ฉันต้องการพูดถึงคือเงื่อนไขต่อเนื่อง เงื่อนไขต่อเนื่อง
ส่วนที่อยู่ก่อนหลังอัฒภาคแรกนี้ในลูป for
นี่คือนิพจน์เชิงตรรกะ
นี่คือเงื่อนไขที่จะประเมินว่าเป็นจริงหรือเท็จ
นี่คือเวลาที่คุณจะกระโดดในลูปหรือออกจากลูป
สิ่งนี้กำหนดว่าควรดำเนินการวนซ้ำต่อไปหรือไม่
ตราบใดที่เงื่อนไขนี้มีค่าเป็น true การวนซ้ำจะดำเนินการต่อไป
คำสั่งทั้งหมดในเนื้อความจะถูกดำเนินการ
โดยทั่วไปจะตรวจสอบค่าของตัวแปรควบคุมลูป
ดังนั้น คุณเริ่มต้นตัวแปรควบคุมลูปในเงื่อนไขเริ่มต้น
แล้วดูในเงื่อนไขความต่อเนื่อง
คุณสามารถใส่ตรรกะหรือนิพจน์เลขคณิตใดๆ ได้ที่นี่ ตราบใดที่คุณรู้ว่าคุณกำลังทำอะไรอยู่
เงื่อนไขความต่อเนื่องได้รับการทดสอบที่จุดเริ่มต้นของลูปแทนที่จะเป็นตอนท้าย
นี่เรียกว่าลูปการทดสอบล่วงหน้า
คุณจะสังเกตเห็นความแตกต่างเมื่อเราพูดถึงลูป do-while ซึ่งเป็นลูปหลังการทดสอบ
แต่ความหมายคือคำสั่งแบบวนซ้ำสามารถดำเนินการได้ครั้งเดียว และสามารถดำเนินการได้
0 ครั้ง
ทั้งหมดขึ้นอยู่กับว่าเงื่อนไขความต่อเนื่องนั้นประเมินว่าเป็นจริงหรือเท็จ
หากประเมินเป็นเท็จ คุณจะไม่มีวันประหารร่างกาย
หากประเมินว่าเป็นจริง คุณจะดำเนินการร่างกายนั้นอย่างน้อยหนึ่งครั้ง
การดำเนินการต่อการวนซ้ำซึ่งอยู่ที่ส่วนท้ายสุดของลูป for หลังจากเครื่องหมายอัฒภาคที่สอง
ซึ่งมักจะทำการปรับเปลี่ยนตัวแปรควบคุมลูปบางประเภท
มันจะเพิ่มหรือลดถ้าเป็นตัวนับลูปหรือถ้าเป็นลูป
Sentinel ก็อาจขอให้ผู้ใช้ป้อนอินพุตเพิ่มเติม
คุณยังสามารถแก้ไขตัวแปรได้มากกว่าหนึ่งรายการ
คุณสามารถแก้ไขตัวแปรควบคุมลูป และคุณสามารถแก้ไขตัวแปรอื่นๆ ได้
คุณเพียงแค่ต้องคั่นด้วยเครื่องหมายจุลภาค
แต่เพื่อสรุปทุกอย่างที่ฉันพูด
เรามีตารางเล็กๆ ที่อธิบายเรื่องนั้น
แต่ก่อนจะพูดถึงเรื่องนั้น เรามาดูตัวอย่างกันก่อน
นี่คือตัวอย่าง เรามีคีย์เวิร์ดสำหรับ
แล้วคุณจะเห็นว่าเรามี int I เท่ากับ 1 j เท่ากับ 2 นั่นคือจุดเริ่มต้นของตัวแปร
และเรากำลังเริ่มต้นตัวแปร 2 ตัวที่นี่ โดยคั่นด้วยเครื่องหมายจุลภาค
โดยทั่วไปแล้วใน for loop มักจะเริ่มต้นเพียงตัวเดียว นั่นคือตัวแปรควบคุมลูป
แต่ในกรณีนี้ เรากำลังเริ่มต้น I และ j
แล้วหลังจากเครื่องหมายอัฒภาคนั้น เราก็มีเงื่อนไข
เราจะเข้าเมื่อไหร่และเมื่อไหร่ที่เราจะออกจากลูปนี้
เราจะเข้าไปตราบเท่าที่ฉันน้อยกว่า 5
นั่นคือนิพจน์บูลีนของเราประเมินเป็นจริงหรือเท็จ
และหลังจากเครื่องหมายอัฒภาคที่สองนั้น
เราจะแก้ไขตัวแปรควบคุมลูปนั้นหรือตัวแปรอื่นๆ ที่เราเกี่ยวข้อง
ตรงนี้เรากำลังใช้เครื่องหมายบวก บวก I นี่คือตัวดำเนินการการเพิ่มขึ้น
คำนำหน้า I แล้วเราก็กำหนด j เท่ากับ j บวก 2
โดยปกติแล้วจะเป็นเงื่อนไข x ของคุณ โดยแก้ไขตัวแปรควบคุมลูปนั้น
แล้วเนื้อความของลูปก็มีคำสั่งเดียว ดังนั้นเราจึงไม่ต้องการวงเล็บ
เราแค่พิมพ์ค่าของ I คูณ j
ดังนั้นผลลัพธ์ที่สร้างโดยรหัสนี้จะเท่ากับค่า
2, 8, 18, 32 และ 50 ในบรรทัดเดียว
การวนซ้ำครั้งแรกของลูป, I จะเท่ากับ 1, j จะเท่ากับ 2
มันจึงบอกว่าผมคูณ j, ซึ่งก็คือ 1 คูณ 2 และมันจะแสดงออกมา
มันจะตรวจสอบเพื่อให้แน่ใจว่าฉันไม่มากกว่า 5 ฉันไม่ใช่ 1
ดังนั้นมันจะกลับไปและดำเนินการเป็นครั้งที่สอง
และเรากำลังแก้ไขตัวแปร I ในคำสั่งสุดท้ายของเราด้วย
ในการวนซ้ำครั้งที่สองของลูป ผมจะเท่ากับ 2
และ j จะเท่ากับ 2 บวก 2 ซึ่งก็คือ 4
ตอนนี้เรากำลังจะคูณ 2 กับ 4, ซึ่งก็คือ 8
แล้วเราจะแสดงมัน แล้วเราจะตรวจสอบว่า
I มากกว่า 5 หรือไม่? ไม่ ฉันยัง 2
เราจึงแก้ไข I ให้เท่ากับ 3 สำหรับการวนซ้ำครั้งถัดไป
และเราแก้ไข j ให้เท่ากับ 4 บวก 2 ซึ่งเท่ากับ
6
แล้วสำหรับการวนซ้ำครั้งที่สามของลูป
เราคูณ I กับ J เราจึงบอกว่า 3 คูณ 6 และแสดง 18
ก่อนที่เราจะดำเนินการวนซ้ำครั้งที่สี่ เราจะตรวจสอบเพื่อดูว่าฉันมากกว่า 5 หรือไม่
ไม่ มัน 4 แล้วเราก็เพิ่มมัน เราว่ามันคือ 5 เท่ากับ 5 ดังนั้นมันจะยังคงทำงานอยู่
จากนั้นเราจะทำ 32, แล้วก็ทำ 50.
ดังนั้นนี่คือคำสั่งสำหรับ คุณต้องการเรียกใช้และดำเนินการในเบราว์เซอร์โค้ดและเล่นและเปลี่ยนแปลงสิ่งต่างๆ
แต่สิ่งที่เราทำที่นี่ คือ เราทำ 3 สิ่งแยกกันในโค้ดบรรทัดเดียว
เรากำลังเริ่มต้นตัวแปรควบคุมลูปหรือตัวแปรอื่นๆ
เรามีนิพจน์บูลีนหลังจากเครื่องหมายอัฒภาคแรก เงื่อนไขการออกของเรา
จากนั้นเรากำลังแก้ไขตัวแปรควบคุมลูปและตัวแปรอื่น ๆ ที่เราต้องการเป็นส่วนสุดท้ายของคำสั่ง
for
เพื่อสรุปสิ่งที่เรากำลังทำ ฉันพบแผนภูมิที่มีประโยชน์เล็กๆ น้อยนี้จากหนังสือ
และฉันต้องการแสดงให้คุณเห็น นี้สรุปทุกอย่าง
อัฒภาคแรกนั้นเริ่มต้นตัวแปรควบคุมลูป
หลังจากเครื่องหมายอัฒภาคแรก เรากำลังทำเงื่อนไข นิพจน์บูลีนของเรา
และหลังจากเครื่องหมายอัฒภาคที่สอง
เรากำลังแก้ไขตัวแปรควบคุมลูปนั้น และนี่คือตัวอย่างทั่วไปที่คุณเห็น
นี่คือการวนรอบการควบคุมเคาน์เตอร์ที่เริ่มต้นที่ 1 และไปจนถึง 10
นี่จึงจะได้ผลจริง 10 ครั้ง
ที่สำคัญมีน้อยกว่าเท่ากับ 10 ดังนั้นคุณจะเห็นโอเปอเรเตอร์เชิงสัมพันธ์เป็นเงื่อนไขของเรา
เช่นเดียวกับที่เราเห็นโอเปอเรเตอร์เชิงสัมพันธ์เป็นเงื่อนไขของเราในคำสั่ง if
กุญแจสำคัญที่นี่คือคุณต้องการแก้ไขตัวแปรควบคุมลูปนั้นหรือคุณจะไม่มีวันออก
ดังนั้นการนับบวกจึงมีความสำคัญมาก
และสำหรับการเพิ่มขึ้นก่อนหรือหลังไม่ว่าค่า plus plus จะอยู่ก่อนตัวแปรหรือหลังตัวแปร
คุณไม่จำเป็นต้องกังวลเกี่ยวกับมัน
เพราะมันจะเพิ่มขึ้นหรือลดลงหลังจากการวนซ้ำของลูปเท่านั้น ดังนั้นมันจึงไม่'
ไม่ว่าคุณจะบวกบวกนับหรือนับบวกบวก
และอีกครั้งขึ้นอยู่กับเวอร์ชันของ c ที่คุณใช้สำหรับคอมไพเลอร์ของคุณ
คุณอาจสามารถประกาศการนับตัวแปรภายใน for loop หรือคุณอาจต้องบอกว่า
int count เท่ากับ 1 หรือนับนอก for loop และ แล้วเริ่มต้นในอัฒภาคแรก
C99 เพิ่มการเริ่มต้นและการประกาศในส่วนเดียวกันของลูป
for
แต่นี่เป็นวิธีการทำงานของลูปโดยพื้นฐาน
มาดูตัวอย่างกัน ฉันต้องการแสดงความยืดหยุ่นของ for loop
นี่คือตัวอย่างที่เราจะสรุปเฉพาะจำนวนเต็ม
และในตัวอย่างนี้ เราจะขอให้ผู้ใช้ป้อนจำนวนเต็มที่ต้องการรวม
เราจะเก็บมันไว้ในตัวแปรที่เรียกว่าการนับ
ตอนนี้เราจะมี for loop ที่จะผ่านสิ่งเหล่านี้ทั้งหมดขึ้นอยู่กับจำนวนที่พวกเขาป้อนวนซ้ำหลายครั้ง
ที่นี่เราบอกว่า 4 เรามี unsigned int ไม่จำเป็นต้อง unsigned
สำหรับ int I เท่ากับ 1 เรากำลังเริ่มต้นตัวแปรควบคุมลูป
แล้วเรากำลังบอกว่าถ้าฉันน้อยกว่าที่จะนับ นั่นคือตอนที่เรากำลังจะออก
แล้วเราจะแก้ไขวัสดุลูป บวก บวก I
นี่จึงจะวิ่งไป อีกครั้ง
1 กับจำนวนที่ผู้ใช้ป้อน 10 หรือ 20
และสิ่งที่เราจะทำคือเราจะบอกว่าผลรวมเท่ากับผลบวก 1
ตอนนี้ for loop นั้นทรงพลังมากเพราะ for loop ให้คุณแก้ไขตัวแปรได้หลายตัว
เราไม่จำเป็นต้องใส่ผลรวมนั้นบวกเท่ากับ I ในส่วนของ for loop
เราสามารถใส่ไว้ท้ายประโยคสุดท้ายได้
นอกจากการเพิ่ม I ขึ้น 1 แล้ว เราก็บอกว่าผลรวมบวกเท่ากับ I บวกบวกได้
ดังนั้นเราจึงทำทุกอย่างในโค้ดบรรทัดเดียว
และนั่นแสดงให้คุณเห็นถึงความยืดหยุ่น ทั้งหมดเป็นเพราะเราสามารถแก้ไขตัวแปรในคำสั่ง
for ได้เอง เราไม่จำเป็นต้องมีร่างกายเส้นนั้น
ลองมาดูตัวอย่างนี้ในบล็อคโค้ดเพื่อแสดงให้คุณเห็นว่าคุณสามารถจัดการมันได้อย่างไร
และดูว่าผลลัพธ์คืออะไร
นี่คือตัวอย่างของเราที่เรามีในการบรรยาย ฉันต้องการไปข้างหน้าและพยายามรวบรวมสิ่งนี้
และเมื่อฉันรวบรวมสิ่งนี้ คุณจะสังเกตเห็นว่าฉันมีข้อผิดพลาด
มันบอกว่าฉันไม่สามารถประกาศตัวแปรภายในคำสั่ง for ได้ นี่เป็นเพราะฉันใช้คอมไพเลอร์
c เวอร์ชันเก่า ฉันใช้ C89
คุณคงไม่มีสิ่งนี้
แต่เพื่อแก้ปัญหา ถ้าคุณเคยเห็นข้อผิดพลาดประเภทนี้ ทั้งหมดที่คุณต้องล้างมันนอก
for loop ดังนั้นคุณก็แค่พูดว่า unsigned I.
จากนั้นใน for loop คุณเริ่มต้นมัน
ประมาณนี้ ตอนนี้ มาลองสร้างกัน และฉันต้องกำจัดตัวระบุรูปแบบเหล่านี้ออกไป
ดังนั้นเมื่อฉันคอมไพล์สำเร็จและรันโปรแกรมนี้
คุณจะเห็นว่าลูปทำงานอย่างไร
มันจะขอให้ฉันป้อนจำนวนเต็มที่อยากบวก ถ้าผมใส่ 5, มันจะรวมเป็น
1 2 3 4 และ 5 ซึ่งก็คือ 15.
และสิ่งที่เราสามารถทำได้เพื่อแก้ไขจุดบกพร่องนี้คือ เราสามารถเพิ่มวงเล็บลงใน
for loop ได้ และเราต้องการดูจำนวนครั้งที่มันทำงาน เราสามารถเพิ่มคำสั่ง print
ที่ไม่จำเป็นต้องทำการดีบั๊ก แต่แค่ดูว่าเกิดอะไรขึ้น เราสามารถพูดได้ว่าวงใน
และนี่จะบอกเราว่าลูปรัน 5 ครั้ง
เพราะมันจะรัน I เพื่อนับ
สิ่งที่ฉันต้องการแสดงให้เห็นคือจำนวนครั้งที่มันทำงาน ตอนนี้เมื่อฉันสร้างมันขึ้นมาและรันมัน
ฉันจะดูว่าเกิดอะไรขึ้นกับการทำซ้ำแต่ละครั้ง
ดังนั้นฉันจะพูด 8
วงใน วงใน วงใน ฉันไม่ได้เพิ่มการป้อนบรรทัด ดังนั้นมันจึงยากที่จะอ่าน
แต่วงในแสดง 8 ครั้ง
แล้วผมก็สรุปตัวเลขแต่ละตัวในลูป ดังนั้นคำตอบคือ
36, 1 บวก 2 บวก 3 บวก 4 บวก 5 บวก 6 บวก 7 บวก 8
ดังนั้นคุณสามารถเล่นกับสิ่งนี้ได้ แต่เราเริ่มต้นตัวแปรควบคุมลูปของเราอีกครั้ง
เราตรวจสอบเงื่อนไขที่จะออก เราจะออกเมื่อเรากดสิ่งที่ผู้ใช้ป้อน
หากผู้ใช้ป้อน 8 เราจะเรียกใช้
8 ครั้ง จากนั้นเราต้องแก้ไข I ถ้าเราไม่แก้ไข I ที่นี่ คุณจะมีลูปตลอดไป
และอะไรจะเกิดขึ้นเมื่อคุณรันโปรแกรม
มันจะรันตลอดไป
คุณจะเห็นว่าหลังจากที่คุณป้อนหมายเลขแล้ว โปรแกรมของคุณจะไม่มีวันออก
สมมติว่าเราป้อน 6 ฉันกด Enter ดูว่าเกิดอะไรขึ้น
แค่พิมพ์วนภายใน มันไม่เคยออก
มันเป็นวงวนที่ไม่มีที่สิ้นสุด ดังนั้นสิ่งสุดท้ายจึงสำคัญมาก คุณต้องการแก้ไขตัวแปรควบคุมลูปเสมอ
และอีกครั้ง ตัวแปรควบคุมลูปจะกำหนดทางออก ในกรณีนี้คือ I
ดังนั้น for loop จึงถูกใช้ค่อนข้างน้อย
มันใช้งานง่ายมากและให้คุณทำ 3 สิ่งที่แตกต่างกันภายในลูป
เริ่มต้นตัวแปรควบคุมลูป ตรวจสอบการควบคุมลูปของตัวแปรสำหรับเงื่อนไขการออก
แล้วแก้ไขตัวแปรควบคุมลูปนั้น
นี่คือ 3 สิ่งที่คุณต้องทำในลูป และคุณสามารถทำได้ในคำสั่งเดียว
ตอนนี้ให้ฉันพูดถึงการวนรอบอนันต์อย่างรวดเร็ว
ดังนั้นฉันจึงแสดงการวนซ้ำที่ไม่สิ้นสุด นี่คือที่ที่คุณไม่เคยออก
และคุณไม่จำเป็นต้องใส่พารามิเตอร์ใดๆ ในคำสั่ง for loop
จริงๆ แล้ว คุณสามารถเขียนวนซ้ำแบบอนันต์โดยตั้งใจ
วิธีที่คุณจะทำคือใส่เครื่องหมายอัฒภาคลงไป
คุณจะได้ for loop ที่มีเครื่องหมายอัฒภาค 2 ตัว
หากคุณเคยเห็นสิ่งนั้น แสดงว่าคุณกำลังเขียนวนไม่สิ้นสุด
โดยทั่วไปแล้ว คุณไม่ต้องการให้มีการวนซ้ำแบบอนันต์
แต่มีบางครั้งเนื่องจากไม่มีเงื่อนไขในการวนซ้ำ
การวนซ้ำจะดำเนินต่อไปอย่างไม่มีกำหนด บางครั้งมีประโยชน์หากคุณกำลังตรวจสอบข้อมูล
ดังนั้น หากคุณกำลังตรวจสอบข้อมูล คุณอาจมีบางอย่างอยู่ในนั้น
โดยปกติ เมื่อคุณมีการวนซ้ำแบบถาวร คุณมักจะมีโหมดสลีปด้วย ซึ่งจะหยุดการทำงานของโปรแกรมชั่วคราว
บางทีอาจเป็นวินาทีที่คุณกำลังติดตามบางสิ่งบางอย่าง
กรณีการใช้งานอื่นที่คุณอาจมีลูปไม่สิ้นสุดคือถ้าคุณกำลังฟังการเชื่อมต่อ
ดังนั้น หากคุณกำลังรอและกำลังรับฟังการเชื่อมต่อ หรือหากคุณกำลังดึงบางอย่างเพื่อดูบางสิ่ง
คุณก็อาจจะทำเช่นนั้น
ตอนนี้บางคนโต้แย้งว่าคุณไม่ควรดึงและไม่ควรฟัง
แต่นั่นเป็นอีกข้อโต้แย้ง
นั่นเป็นกรณีเดียวสำหรับบางลูปที่ไม่มีที่สิ้นสุด
หลีกเลี่ยงลูปอนันต์ให้มากที่สุดโดยแก้ไขตัวแปรควบคุมลูปนั้น
ฉันหวังว่านี่จะเป็นประโยชน์ นี่คือลูปสำหรับ
เราจะใช้ for loop ในการท้าทายของเรา ดังนั้นเราจึงคุ้นเคยมากขึ้น
ขอขอบคุณ.