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

ลูปเป็นคุณลักษณะของภาษาโปรแกรมระดับสูงในภาษาโปรแกรมระดับต่ำฟังก์ชันเดียวกันนี้สามารถทำได้โดยใช้การกระโดดเมื่อโปรแกรมถูกคอมไพล์เป็นรหัสเครื่องการวนลูปอาจทำได้โดยใช้การกระโดด แต่ลูปบางลูปสามารถปรับให้เหมาะสมเพื่อทำงานโดยไม่ต้องกระโดด^{[ 1 ]}

โดยปกติแล้ว ลูปจะทำงานเป็นจำนวนรอบที่จำกัด หากไม่ระมัดระวัง ลูปที่ไม่สามารถสิ้นสุดได้อาจถูกสร้างขึ้นโดยไม่ได้ตั้งใจ ลูปดังกล่าวเรียกว่าลูปอนันต์ปัญหาในการตรวจสอบว่าโปรแกรมมีลูปอนันต์หรือไม่ เรียกว่าปัญหาการหยุดทำงาน (halting problem )

ลูปแบบมีเงื่อนไข (หรือเรียกอีกอย่างว่าลูปที่ไม่แน่นอน^{[ 2 ]} ) คือลูปที่กำหนดว่าจะสิ้นสุดหรือไม่โดยอาศัยเงื่อนไขเชิงตรรกะ^{[ 3 ]}ลูปเหล่านี้มีความยืดหยุ่น แต่พฤติกรรมที่แน่นอนของลูปเหล่านี้อาจยากที่จะเข้าใจได้^{[ 4 ] : 368}

ลูปเงื่อนไขมักประกอบด้วยสองส่วน คือเงื่อนไขและส่วนเนื้อหาเงื่อนไขคือข้อความตรรกะที่ขึ้นอยู่กับสถานะของโปรแกรม และส่วนเนื้อหาคือบล็อกของโค้ดที่จะทำงานตราบใดที่เงื่อนไข ยัง คงเป็นจริง^{[ 3 ]}

ความเข้าใจผิดทั่วไปคือการดำเนินการของเนื้อหาจะสิ้นสุดลงทันทีที่เงื่อนไขไม่เป็นจริงอีกต่อไป แต่โดยปกติแล้วจะไม่เป็นเช่นนั้น^{[ 4 ] : 368} ในภาษาโปรแกรมส่วนใหญ่เงื่อนไขจะถูกตรวจสอบหนึ่งครั้งสำหรับการดำเนินการแต่ละครั้งของเนื้อหาเวลา ที่ตรวจสอบ เงื่อนไขนั้นไม่มีมาตรฐาน และภาษาโปรแกรมบางภาษามีโครงสร้างการวนซ้ำแบบมีเงื่อนไขหลายแบบที่มีกฎที่แตกต่างกันเกี่ยวกับเวลาที่ประเมิน เงื่อนไข

ลู ปแบบตรวจสอบเงื่อนไข (Pre-test loop)คือลูปที่มีเงื่อนไข โดยจะตรวจสอบเงื่อนไข ก่อนที่ จะดำเนินการส่วนของโค้ด กล่าวคือ จะตรวจสอบเงื่อนไข ก่อน และถ้าเป็นจริง ส่วนของโค้ดก็จะถูกดำเนินการ จากนั้นจะตรวจสอบเงื่อนไข อีกครั้ง และถ้าเป็นจริงอีกครั้ง ส่วนของโค้ดก็จะถูกดำเนินการอีกครั้ง กระบวนการนี้จะทำซ้ำไปเรื่อยๆ จนกว่าเงื่อนไขจะไม่เป็นจริง ภาษาโปรแกรมหลายภาษาเรียกวงจรนี้ว่า ลูป whileและใช้คำหลักwhile ในการอ้างอิง โดยทั่วไปแล้ว รูปแบบของลูปจะคล้ายกับ ` while`

ในขณะที่เงื่อนไข ทำให้ ร่างกายทำซ้ำ

แทนที่จะใช้คำหลักdoและrepeatบางครั้งมีการใช้วิธีอื่นเพื่อระบุจุด เริ่มต้นและจุดสิ้นสุด ของเนื้อหาเช่นวงเล็บปีกกา^{[ 5 ]}หรือช่องว่าง^{[ 6 ]}

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

x ← 0 ในขณะที่x < 5 ให้ แสดงค่าx x ← x + 1 ทำซ้ำ

ลูปแบบ post-testคือลูปแบบมีเงื่อนไข โดยจะตรวจสอบเงื่อนไข หลังจากที่ ส่วนของโค้ดทำงานเสร็จแล้ว กล่าวคือส่วนของโค้ดจะทำงานก่อน จากนั้น จึงตรวจสอบ เงื่อนไขหากเงื่อนไขเป็นจริงส่วนของโค้ดจะทำงานอีกครั้ง แล้วจึงตรวจสอบเงื่อนไข อีกครั้ง ทำซ้ำเช่นนี้จนกว่า เงื่อนไขจะไม่เป็นจริง บางครั้งเรียกว่าลูป do-whileเนื่องจากไวยากรณ์ที่ใช้ในภาษาโปรแกรมต่างๆ^{[ 7 ]}แม้ว่าสิ่งนี้อาจทำให้สับสนได้ เนื่องจากFortranและPL/Iใช้ไวยากรณ์ "DO WHILE" สำหรับลูปแบบ pre-test ^{[ 8 ] [ 9 ]}ลูปแบบ post-test มักจัดรูปแบบในลักษณะที่คล้ายกับ

ทำซ้ำร่างกายในขณะที่ปรับสภาพ

แทนที่จะใช้คำหลักdoและrepeatบางครั้งมีการใช้วิธีอื่นเพื่อระบุจุด เริ่มต้นและจุดสิ้นสุด ของเนื้อหาเช่น วงเล็บปีกกา^{[ 10 ]}

บางภาษาอาจใช้รูปแบบการตั้งชื่อที่แตกต่างกันสำหรับลูปประเภทนี้ ตัวอย่างเช่น ภาษา PascalและLuaมีลูป " repeat until " ซึ่งจะทำงานต่อไปจนกว่านิพจน์ควบคุมจะเป็นจริงแล้วจึงสิ้นสุด^{[ 11 ] [ 12 ]}

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

สำหรับการเริ่มต้นเงื่อนไขการเพิ่มค่า ให้ทำซ้ำส่วนเนื้อหา

ไวยากรณ์นี้มาจากBและเดิมทีคิดค้นโดยStephen C. Johnson [ ^{13 ] โค้ด} C ต่อไปนี้เป็นตัวอย่างของลูปสามส่วนที่พิมพ์ตัวเลขตั้งแต่ 0 ถึง 4

for ( int i = 0 ; i < 5 ; i ++ ) { printf ( "%d \n " , i ); }

สมมติว่ามีฟังก์ชันหรือเมธอดที่ประกาศอย่างถูกต้องเรียกว่าdo_work()ต่อไปนี้จะเทียบเท่ากันในภาษาโปรแกรมที่รองรับลูปหลังการทดสอบ^{[ 14 ]}

ทำ ทำงาน() ทำซ้ำในขณะที่เงื่อนไข

do_work() ในขณะที่เงื่อนไขdo ทำงาน() ทำซ้ำ

นอกจากนี้ เนื่องจากcontinueไม่ได้ใช้คำสั่งดังกล่าว ข้างต้นจึงเทียบเท่ากับต่อไปนี้ในทางเทคนิค แม้ว่าตัวอย่างเหล่านี้จะไม่ใช่รูปแบบทั่วไปหรือรูปแบบสมัยใหม่ที่ใช้ในคอมพิวเตอร์ทั่วไปก็ตาม^{[ 15 ] [ 16 ]}

ในขณะที่ความจริงนั้น ทำงาน() ถ้าเงื่อนไขไม่เป็นจริงให้หยุดและทำซ้ำ

หรืออีกทางเลือกหนึ่ง

LOOPSTART: ทำงาน() ถ้าเงื่อนไข เป็นจริง ให้ไปที่ LOOPSTART จบเงื่อนไข

การแจงนับ (หรือเรียกอีกอย่างว่าลูปแบบกำหนด^{[ 2 ]} ) คือลูปที่มีจุดประสงค์เพื่อวนซ้ำรายการทั้งหมดของคอลเลกชัน^{[ 17 ]}มันไม่ยืดหยุ่นเท่าลูปแบบมีเงื่อนไข แต่สามารถคาดเดาได้ง่ายกว่า ตัวอย่างเช่น การรับประกันว่าการแจงนับจะสิ้นสุดนั้น ง่ายกว่า และช่วยหลีกเลี่ยงข้อผิดพลาด ที่อาจเกิดขึ้นได้ การแจงนับสามารถนำไปใช้โดยใช้ตัววนซ้ำไม่ว่าจะโดยปริยายหรือโดยชัดแจ้ง

ขึ้นอยู่กับภาษาการเขียนโปรแกรม มีการใช้คำหลักต่างๆ เพื่อเรียกใช้การแจงนับ ตัวอย่างเช่น ลูกหลานของALGOLใช้for, ^{[ 18 ]}ในขณะที่ลูกหลานของFortranใช้do^{[ 19 ]}และCOBOLใช้PERFORM VARYING. ^{[ 20 ]}

^{บางครั้งการแจงนับจะถูกเรียกว่า "ลูป for} " เช่นในZigและRust [ ^{21 ] [ 22 ]}ซึ่งอาจทำให้สับสนได้ เนื่องจากภาษาโปรแกรมยอดนิยมหลายภาษา^{[ 23 ]}เช่น C, C++และJavaใช้คำนี้สำหรับลูป for สามส่วน^{[ 24 ] [ 25 ] [ 26 ]}ซึ่งไม่ใช่การแจงนับ ภาษาโปรแกรมอื่นๆ เช่นPerlและC#หลีกเลี่ยงความสับสนนี้โดยใช้คำว่า "ลูป foreach" ^{[ 27 ] [ 28 ]}

ลำดับการวนซ้ำของรายการในคอลเลกชันขึ้นอยู่กับภาษาการเขียนโปรแกรมFortran 95มีลูปที่เรียกใช้โดยใช้คำหลักFORALLซึ่งเป็นอิสระจากลำดับนี้ มีผลทำให้การวนซ้ำแต่ละครั้งของลูปทำงานพร้อมกัน คุณสมบัตินี้ถูกยกเลิกในFortran 2018 ^{[ 29 ]}

ในภาษาการเขียนโปรแกรมเชิงฟังก์ชัน ส่วนใหญ่ จะ ใช้ การเรียกซ้ำแทนลูปแบบดั้งเดิม เนื่องจากตัวแปรไม่สามารถเปลี่ยนแปลงได้ดังนั้น ขั้นตอน การเพิ่มค่าของลูปจึงไม่สามารถเกิดขึ้นได้^{[ 30 ]}

เพื่อหลีกเลี่ยงการเกิด ข้อผิดพลาด stack overflowสำหรับลูปที่ยาว ภาษาการเขียนโปรแกรมเชิงฟังก์ชันจะใช้การเพิ่มประสิทธิภาพการเรียกแบบ tail callซึ่งช่วยให้สามารถ ใช้ เฟรมสแต็ก เดียวกัน สำหรับการวนซ้ำแต่ละครั้งของลูป ทำให้สามารถคอมไพล์เป็นโค้ดเดียวกันกับลูปwhileหรือfor ได้อย่างมีประสิทธิภาพ ^{[ 31 ]}

บางภาษา เช่นHaskellมีไวยากรณ์ที่เรียกว่าlist comprehensionซึ่งคล้ายกับการแจงนับ โดยจะวนซ้ำไปตามเนื้อหาของลิสต์และแปลงให้เป็นลิสต์ใหม่

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

ธรรมเนียมการตั้งชื่อตัวระบุทั่วไปคือการใช้ชื่อตัวแปรi , jและk (และอื่นๆ หากจำเป็น) สำหรับตัวนับลูป ^{[ 32 ]}โดยที่iจะเป็นลูปภายนอกสุดjเป็นลูปภายในถัดไป เป็นต้น โดยทั่วไปแล้วเชื่อกันว่ารูปแบบนี้มีต้นกำเนิดมาจากการเขียนโปรแกรม Fortran ในยุคแรกๆ ซึ่งชื่อตัวแปรที่ขึ้นต้นด้วยตัวอักษรเหล่านี้จะถูกประกาศโดยปริยายว่าเป็นชนิดจำนวนเต็ม ดังนั้นจึงเป็นตัวเลือกที่ชัดเจนสำหรับตัวนับลูปที่ต้องการเพียงชั่วคราวเท่านั้น แนวปฏิบัตินี้มีมานานกว่านั้นอีกใน สัญกร ณ์ ทางคณิตศาสตร์ที่ดัชนีสำหรับผลรวมและการคูณมักจะเป็นi , jและk

บางคนไม่แนะนำ ให้ใช้ชื่อย่อสำหรับตัวนับลูป เช่นiและjเนื่องจากวัตถุประสงค์ของตัวแปรไม่ชัดเจนเท่ากับการใช้ชื่อที่ยาวกว่าและสื่อความหมายได้ดีกว่า^{[ 4 ] : 383–382}

ภาษาโปรแกรมแต่ละภาษามีนิยามที่แตกต่างกันเกี่ยวกับค่าที่ตัวนับลูปจะเก็บไว้เมื่อลูปสิ้นสุดลง และบางภาษาก็กำหนดว่าค่าของตัวนับลูปจะไม่ถูกนิยาม สิ่งนี้ทำให้คอมไพเลอร์สามารถสร้างโค้ดที่คงค่าใดๆ ก็ได้ในตัวนับลูป หรืออาจจะไม่เปลี่ยนแปลงเลยก็ได้ เพราะค่าของลูปถูกเก็บไว้ในรีจิสเตอร์ ไม่ได้ถูกเก็บไว้ในหน่วยความจำ พฤติกรรมที่แท้จริงอาจแตกต่างกันไปตามการตั้งค่าการเพิ่มประสิทธิภาพของคอมไพเลอร์ด้วยซ้ำ

การแก้ไขตัวนับลูปภายในตัวลูปเองอาจนำไปสู่ผลลัพธ์ที่ไม่คาดคิด เพื่อป้องกันปัญหาดังกล่าว ภาษาโปรแกรมบางภาษาจึงกำหนดให้ตัวนับลูปไม่สามารถเปลี่ยนแปลงได้อย่างไรก็ตาม คอมไพเลอร์มักจะตรวจจับได้เฉพาะการเปลี่ยนแปลงที่เห็นได้ชัดเท่านั้น สถานการณ์ที่ส่งที่อยู่ของตัวนับลูปเป็นอาร์กิวเมนต์ไปยังซับรู ทีน ทำให้การตรวจสอบทำได้ยากมาก เนื่องจากโดยทั่วไปแล้วพฤติกรรมของรูทีนนั้นคอมไพเลอร์ไม่สามารถทราบได้ เว้นแต่ว่าภาษานั้นจะรองรับลายเซ็นของขั้นตอนและเจตนาของอาร์กิวเมนต์

บางภาษาอาจมีคำสั่งสนับสนุนสำหรับการเปลี่ยนแปลงวิธีการวนซ้ำของลูป คำสั่งที่พบบ่อย ได้แก่ คำสั่ง breakซึ่งจะยุติลูปปัจจุบันที่โปรแกรมกำลังทำงานอยู่ และ คำสั่ง continueซึ่งจะข้ามไปยังการวนซ้ำครั้งถัดไปของลูปปัจจุบัน^{[ 4 ] : 379} คำสั่งเหล่านี้อาจมีชื่ออื่น ตัวอย่างเช่น ในFortran 90เรียกว่า exitและcycle

ลูปสามารถยุติได้โดยการส่งค่ากลับจากฟังก์ชันที่ลูปนั้นกำลังทำงานอยู่

ในกรณีของลูปซ้อนกัน คำสั่ง breakและcontinueจะใช้กับลูปที่อยู่ด้านในสุด ภาษาโปรแกรมบางภาษาอนุญาตให้ติดป้ายกำกับให้กับลูปได้ จากนั้นจึงสามารถใช้คำสั่งเหล่านี้กับลูปใดก็ได้ที่โปรแกรมซ้อนอยู่

outer_loop: (นี่คือป้ายกำกับสำหรับลูปนอกสุด) for 1 ≤ i ≤ 2 do for 1 ≤ j ≤ 2 do แสดงผล (i, j) ถ้า i = 2 ให้วน ลูปภายนอก ต่อไปจบ ลู ป ทำซ้ำ(ลูปซ้อนนี้แสดงคู่ (1, 1), (1, 2) และ (2, 1))

ลูปอนันต์คือลูป ที่ ไม่สิ้นสุด ซึ่งอาจเกิดขึ้นโดยตั้งใจ หรือเป็นผลมาจากข้อผิดพลาดทางตรรกะ

การตรวจจับลูปอนันต์อย่างเป็นระบบเรียกว่าปัญหาการหยุดทำงาน (halting problem )

^{ลูปอนันต์มีประโยชน์ในแอ ป}พลิเคชันที่ต้องการทำการคำนวณซ้ำๆ จนกว่าโปรแกรมจะสิ้นสุด เช่นเว็บเซิร์ฟเวอร์ [ ^{33 ]}

• ฟังก์ชันเรียกซ้ำแบบดั้งเดิม
• ฟังก์ชันเรียกซ้ำทั่วไป
• วนซ้ำ (การแยกความหมาย)
• LOOP (ภาษาโปรแกรม) – ภาษาโปรแกรมที่มีคุณสมบัติว่าฟังก์ชันที่สามารถคำนวณได้นั้นเป็นฟังก์ชันเรียกซ้ำแบบดั้งเดิมอย่างแท้จริง