การใช้ break in a for loop เป็นการปฏิบัติที่ไม่ดีหรือไม่? [ปิด]

การใช้breakคำสั่งภายในforลูปเป็นการปฏิบัติที่ไม่ดีหรือไม่?

สมมติว่าฉันกำลังค้นหาค่าในอาร์เรย์ เปรียบเทียบภายใน for loop และเมื่อพบค่าbreak;เพื่อออกจาก for loop

เป็นการปฏิบัติที่ไม่ดีหรือไม่? ฉันได้เห็นทางเลือกที่ใช้: กำหนดตัวแปรvFoundและตั้งค่าเป็นจริงเมื่อพบค่าและตรวจสอบvFoundในforเงื่อนไขคำสั่ง แต่จำเป็นต้องสร้างตัวแปรใหม่เพื่อจุดประสงค์นี้หรือไม่?

ฉันกำลังถามในบริบทของ C หรือ C ++ ปกติสำหรับลูป

PS: หลักเกณฑ์การเข้ารหัส MISRA ไม่แนะนำให้ใช้ตัวแบ่ง

มีคำตอบมากมายที่นี่ แต่ฉันยังไม่เห็นสิ่งนี้:

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

หากลูปมีขนาดใหญ่เกินไปให้ใช้ฟังก์ชันที่มีชื่อดีอย่างน้อยหนึ่งฟังก์ชันเรียกภายในลูปแทน เหตุผลเดียวที่แท้จริงที่ควรหลีกเลี่ยงคือการประมวลผลคอขวด

ไม่แตกเป็นวิธีแก้ปัญหาที่ถูกต้อง

การเพิ่มตัวแปรบูลีนทำให้โค้ดอ่านยากขึ้นและเพิ่มแหล่งที่มาของข้อผิดพลาด

คุณสามารถค้นหารหัสมืออาชีพทุกประเภทที่มีคำสั่ง 'break' อยู่ในนั้น ควรใช้สิ่งนี้ทุกครั้งที่จำเป็น ในกรณีของคุณตัวเลือกนี้ดีกว่าการสร้างตัวแปรแยกเฉพาะเพื่อจุดประสงค์ในการออกมาจากลูป

การใช้breakเช่นเดียวกับcontinueการforวนซ้ำทำได้ดีมาก

ช่วยลดความซับซ้อนของรหัสและปรับปรุงการอ่าน

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

for n in range(5):
    for m in range(3):
        if m >= n:
            print('stop!')
            break
        print(m, end=' ')
    else:
        print('finished.')

เอาท์พุท:

stop!
0 stop!
0 1 stop!
0 1 2 finished.
0 1 2 finished.

รหัสเทียบเท่าที่ไม่มีbreakและมีประโยชน์else:

for n in range(5):
    aborted = False
    for m in range(3):
        if not aborted:
            if m >= n:
                print('stop!')
                aborted = True
            else:            
                print(m, end=' ')
    if not aborted:
        print('finished.')

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

int[] iArray = new int[]{0,1,2,3,4,5,6,7,8,9};
int[] jArray = new int[]{0,1,2,3,4,5,6,7,8,9};

// label for i loop
iLoop: for (int i = 0; i < iArray.length; i++) {

    // label for j loop
    jLoop: for (int j = 0; j < jArray.length; j++) {

        if(iArray[i] < jArray[j]){
            // break i and j loops
            break iLoop;
        } else if (iArray[i] > jArray[j]){  
            // breaks only j loop
            break jLoop;
        } else {
            // unclear which loop is ending
            // (breaks only the j loop)
            break;
        }
    }
}

ฉันจะบอกว่าคำสั่ง break (และ return) มักเพิ่มความซับซ้อนของวัฏจักรซึ่งทำให้ยากต่อการพิสูจน์ว่า code กำลังทำสิ่งที่ถูกต้องในทุกกรณี

หากคุณกำลังพิจารณาที่จะใช้ช่วงพักขณะที่ทำซ้ำตามลำดับสำหรับบางรายการคุณอาจต้องการพิจารณาโครงสร้างข้อมูลที่ใช้เก็บข้อมูลของคุณใหม่ การใช้บางอย่างเช่น Set หรือ Map อาจให้ผลลัพธ์ที่ดีกว่า

breakเป็นคำสั่งที่ยอมรับได้อย่างสมบูรณ์ในการใช้ (ดังนั้นต่อไป btw) ทุกอย่างเกี่ยวกับความสามารถในการอ่านโค้ด - ตราบใดที่คุณไม่มีลูปที่ซับซ้อนเกินไปก็ใช้ได้

มันไม่ได้เป็นอย่างที่พวกเขาลีกเช่นเดียวกับโกโตะ :)

กฎทั่วไป: หากการปฏิบัติตามกฎทำให้คุณต้องทำสิ่งที่น่าอึดอัดและอ่านยากมากขึ้นจากนั้นฝ่าฝืนกฎก็ฝ่าฝืนกฎ

ในกรณีของการวนซ้ำจนกว่าคุณจะพบบางสิ่งคุณจะพบปัญหาในการแยกแยะพบกับไม่พบเมื่อคุณออกไปข้างนอก นั่นคือ:

for (int x=0;x<fooCount;++x)
{
  Foo foo=getFooSomehow(x);
  if (foo.bar==42)
    break;
}
// So when we get here, did we find one, or did we fall out the bottom?

โอเคคุณสามารถตั้งค่าสถานะหรือเริ่มต้นค่า "พบ" เป็นค่าว่าง แต่

นั่นเป็นเหตุผลที่โดยทั่วไปแล้วฉันชอบที่จะผลักดันการค้นหาให้เป็นฟังก์ชัน

Foo findFoo(int wantBar)
{
  for (int x=0;x<fooCount;++x)
  {
    Foo foo=getFooSomehow(x);
    if (foo.bar==wantBar)
      return foo;
  }
  // Not found
  return null;
}

นอกจากนี้ยังช่วยคลายรหัส ในบรรทัดหลัก "find" จะกลายเป็นคำสั่งเดียวและเมื่อเงื่อนไขซับซ้อนก็จะเขียนเพียงครั้งเดียว

มันขึ้นอยู่กับภาษา ในขณะที่คุณสามารถตรวจสอบตัวแปรบูลีนได้ที่นี่:

for (int i = 0; i < 100 && stayInLoop; i++) { ... }

เป็นไปไม่ได้ที่จะทำเมื่อวนซ้ำอาร์เรย์:

for element in bigList: ...

อย่างไรก็ตามbreakจะทำให้รหัสทั้งสองอ่านได้ง่ายขึ้น

ในตัวอย่างของคุณคุณไม่ทราบจำนวนการวนซ้ำสำหรับfor loop ทำไมไม่ใช้while loop แทนซึ่งทำให้จำนวนการวนซ้ำไม่แน่นอนในตอนเริ่มต้น

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

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

• ทรัพยากรที่ได้มาที่ด้านบนสุดของบล็อกอาจถูกปล่อยออกที่ด้านล่าง (ซึ่งเป็นจริงแม้กระทั่งสำหรับบล็อกที่อยู่ในforลูป) แต่ขั้นตอนการเผยแพร่นั้นอาจข้ามไปโดยไม่ได้ตั้งใจเมื่อการออก "ก่อนกำหนด" เกิดจากbreakคำสั่ง (ใน "สมัยใหม่" C ++, "RAII" ถูกใช้เพื่อจัดการกับสิ่งนี้ด้วยวิธีที่เชื่อถือได้และปลอดภัยโดยทั่วไปแล้ว object จะทำลายทรัพยากรฟรีได้อย่างน่าเชื่อถือไม่ว่าจะออกจากขอบเขตก็ตาม)

• บางคนอาจเปลี่ยนแปลงการทดสอบตามเงื่อนไขในforคำสั่งโดยไม่สังเกตว่ามีเงื่อนไขการออกจากตำแหน่งอื่น ๆ

• คำตอบของ ndim สังเกตว่าบางคนอาจหลีกเลี่ยงbreaks เพื่อรักษาเวลาการทำงานของลูปที่ค่อนข้างสม่ำเสมอ แต่คุณกำลังเปรียบเทียบbreakกับการใช้ตัวแปรควบคุมการออกจากต้นบูลีนโดยที่ไม่ได้ถือ

ทุก ๆ ครั้งที่ผู้คนสังเกตเห็นจุดบกพร่องดังกล่าวตระหนักว่าพวกเขาสามารถป้องกัน / บรรเทาได้ด้วยกฎ "ไม่หยุดพัก" นี้ ... แท้จริงแล้วมีกลยุทธ์ที่เกี่ยวข้องทั้งหมดสำหรับการเขียนโปรแกรมที่ "ปลอดภัยกว่า" ที่เรียกว่า "การเขียนโปรแกรมแบบมีโครงสร้าง" ซึ่งแต่ละฟังก์ชันควรมี จุดเข้าและออกเพียงจุดเดียว (เช่นไม่มี goto ไม่มีการกลับก่อนเวลา) มันอาจกำจัดจุดบกพร่องบางอย่าง แต่ก็แนะนำคนอื่นอย่างไม่ต้องสงสัย ทำไมพวกเขาถึงทำมัน?

• พวกเขามีกรอบการพัฒนาที่สนับสนุนรูปแบบการเขียนโปรแกรม / โค้ดโดยเฉพาะและมีหลักฐานทางสถิติว่าสิ่งนี้ก่อให้เกิดประโยชน์สุทธิในกรอบที่ จำกัด นั้นหรือ
• พวกเขาได้รับอิทธิพลจากแนวทางการเขียนโปรแกรมหรือประสบการณ์ภายในกรอบดังกล่าวหรือ
• พวกเขาเป็นแค่คนโง่เผด็จการหรือ
• ความเฉื่อยในอดีต + ใด ๆ ข้างต้น (เกี่ยวข้องกับเหตุผลที่สามารถใช้ได้กับ C มากกว่า C ++ สมัยใหม่)

มันเป็นเรื่องที่ดีที่สุดที่ถูกต้องในการใช้งานbreak- ตามที่คนอื่น ๆ gotoได้ออกมาชี้ว่ามันไม่มีที่ไหนในลีกเช่นเดียวกับ

แม้ว่าคุณอาจต้องการใช้vFoundตัวแปรเมื่อคุณต้องการตรวจสอบนอกลูปว่าพบค่าในอาร์เรย์หรือไม่ นอกจากนี้จากมุมมองของการบำรุงรักษาการมีธงทั่วไปที่ส่งสัญญาณถึงเกณฑ์การออกอาจมีประโยชน์

ฉันทำการวิเคราะห์บางส่วนเกี่ยวกับ codebase ที่ฉันกำลังทำงานอยู่ (JavaScript 40,000 บรรทัด)

ฉันพบข้อความเพียง 22 รายการbreakในจำนวนนี้:

• 19 ถูกใช้ภายใน switchงบ (เรามีคำสั่ง switch ทั้งหมด 3 รายการเท่านั้น!)
• 2 ถูกใช้ภายในforลูป - รหัสที่ฉันจัดประเภททันทีว่าถูก refactored เป็นฟังก์ชันแยกต่างหากและแทนที่ด้วยreturnคำสั่ง
• สำหรับวงbreakในรอบสุดท้ายwhile... ฉันวิ่งgit blameไปดูว่าใครเขียนอึนี้!

ตามสถิติของฉัน: หากbreakใช้ภายนอกswitchมันเป็นกลิ่นรหัส

ฉันยังค้นหาcontinueงบ ไม่พบเลย

ฉันไม่เห็นเหตุผลใด ๆ ว่าทำไมจึงเป็นการปฏิบัติที่ไม่ดีที่ระบุว่าคุณต้องการดำเนินการ STOP ให้เสร็จสิ้น ณ จุดนั้น

ในโลกฝังตัวมีโค้ดมากมายที่ใช้โครงสร้างต่อไปนี้:

    while(1)
    { 
         if (RCIF)
           gx();
         if (command_received == command_we_are_waiting_on)
           break;
         else if ((num_attempts > MAX_ATTEMPTS) || (TickGet() - BaseTick > MAX_TIMEOUT))
           return ERROR;
         num_attempts++;
    }
    if (call_some_bool_returning_function())
      return TRUE;
    else
      return FALSE;

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

ความคิดเห็นส่วนตัวของฉันคือไม่มีอะไรผิดปกติในการเขียนวนซ้ำในลักษณะนี้ตราบเท่าที่มีการดูแลที่เหมาะสมเพื่อป้องกันไม่ให้วนซ้ำไปเรื่อย ๆ

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

ในกรณีเหล่านี้การตั้งค่าสถานะจะสมเหตุสมผลและตรวจสอบค่าแฟล็กหลังจากทั้งหมดเท่านั้น forวนซ้ำวนซ้ำทั้งหมดทำงานจริงเท่านั้น แน่นอนว่าการวนซ้ำสำหรับการวนซ้ำทั้งหมดจำเป็นต้องเรียกใช้โค้ดที่ยังคงใช้เวลาประมาณเดียวกัน

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

ในกฎMISRA 98 ที่ใช้กับ บริษัท ของฉันใน C dev จะไม่ใช้คำสั่ง break ...

แก้ไข: อนุญาตให้หยุดพักใน MISRA '04

Ofcourse break;คือทางออกในการหยุดลูป for loop หรือ foreach loop ฉันใช้มันใน php ใน foreach และสำหรับ loop และพบว่าใช้งานได้

ฉันไม่เห็นด้วย!

ทำไมคุณถึงเพิกเฉยต่อฟังก์ชันการทำงานในตัวของ for loop ที่จะสร้างขึ้นเอง คุณไม่จำเป็นต้องสร้างล้อใหม่

ฉันคิดว่ามันสมเหตุสมผลกว่าที่จะมีการตรวจสอบของคุณที่ด้านบนสุดของห่วงเช่นนั้น

for(int i = 0; i < myCollection.Length && myCollection[i].SomeValue != "Break Condition"; i++)
{
//loop body
}

หรือหากคุณต้องการประมวลผลแถวก่อน

for(int i = 0; i < myCollection.Length && (i == 0 ? true : myCollection[i-1].SomeValue != "Break Condition"); i++)
{
//loop body
}

ด้วยวิธีนี้คุณสามารถเขียนฟังก์ชันเพื่อดำเนินการทุกอย่างและสร้างโค้ดที่สะอาดขึ้นมาก

for(int i = 0; i < myCollection.Length && (i == 0 ? true : myCollection[i-1].SomeValue != "Break Condition"); i++)
{
    DoAllThatCrazyStuff(myCollection[i]);
}

หรือหากเงื่อนไขของคุณซับซ้อนคุณสามารถย้ายรหัสนั้นออกได้เช่นกัน!

for(int i = 0; i < myCollection.Length && BreakFunctionCheck(i, myCollection); i++)
{
    DoAllThatCrazyStuff(myCollection[i]);
}

"รหัสมืออาชีพ" ที่เต็มไปด้วยตัวแบ่งฟังดูไม่เหมือนรหัสมืออาชีพสำหรับฉัน ดูเหมือนขี้เกียจเขียนโค้ด;)