เปลี่ยนคำสั่งผ่าน ... ควรได้รับอนุญาตหรือไม่? [ปิด]

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

เป็นสิ่งที่ภาษาโปรแกรมไม่ควรอนุญาตอย่างชัดเจน (เช่น C # แม้ว่าจะมีวิธีแก้ปัญหา) หรือเป็นคุณลักษณะของภาษาใด ๆ ที่มีประสิทธิภาพเพียงพอที่จะปล่อยให้อยู่ในมือของโปรแกรมเมอร์หรือไม่?

แก้ไข: ฉันไม่ได้เจาะจงเพียงพอกับสิ่งที่ฉันหมายถึงโดยการตกผ่าน ฉันใช้ประเภทนี้บ่อยมาก:

    switch(m_loadAnimSubCt){
        case 0:
        case 1:
            // Do something
            break;
        case 2:
        case 3:
        case 4:
            // Do something
            break;
   }

อย่างไรก็ตามฉันกังวลเกี่ยวกับเรื่องนี้

   switch(m_loadAnimSubCt){
        case 0:
        case 1:
            // Do something, but fall through to the other cases
            // after doing it.

        case 2:
        case 3:
        case 4:
            // Do something else.
            break;
   }

ด้วยวิธีนี้เมื่อใดก็ตามที่เคสเป็น 0 1 มันจะทำทุกอย่างในคำสั่ง switch ฉันเคยเห็นสิ่งนี้จากการออกแบบและฉันไม่รู้ว่าฉันเห็นด้วยหรือไม่ว่าควรใช้คำสั่ง switch ด้วยวิธีนี้ ฉันคิดว่าตัวอย่างโค้ดแรกเป็นประโยชน์และปลอดภัยมาก อย่างที่สองดูเหมือนจะอันตราย

อาจขึ้นอยู่กับสิ่งที่คุณคิดว่าผิดพลาด ฉันโอเคกับสิ่งนี้:

switch (value)
{
  case 0:
    result = ZERO_DIGIT;
    break;

  case 1:
  case 3:
  case 5:
  case 7:
  case 9:
     result = ODD_DIGIT;
     break;

  case 2:
  case 4:
  case 6:
  case 8:
     result = EVEN_DIGIT;
     break;
}

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

และโปรดทราบว่าฉันใช้นิยามคำถามที่พบบ่อย C ++ของ"ความชั่วร้าย"

มันเป็นดาบสองคม บางครั้งก็มีประโยชน์มาก แต่มักเป็นอันตราย

เมื่อไหร่ดี? เมื่อคุณต้องการ 10 กรณีทั้งหมดดำเนินการในลักษณะเดียวกัน ...

switch (c) {
  case 1:
  case 2:
            ... Do some of the work ...
            /* FALLTHROUGH */
  case 17:
            ... Do something ...
            break;
  case 5:
  case 43:
            ... Do something else ...
            break;
}

กฎข้อหนึ่งที่ฉันชอบคือถ้าคุณเคยทำอะไรแปลก ๆ โดยที่คุณไม่รวมช่วงพักคุณต้องมีความคิดเห็นที่ชัดเจน / * FALLTHROUGH * / เพื่อระบุว่านั่นคือความตั้งใจของคุณ

คุณเคยได้ยินเกี่ยวกับอุปกรณ์ของ Duffหรือไม่? นี่เป็นตัวอย่างที่ยอดเยี่ยมของการใช้สวิตช์ล้มเหลว

เป็นคุณลักษณะที่สามารถใช้ได้และสามารถใช้ในทางที่ผิดได้เช่นเดียวกับคุณลักษณะภาษาเกือบทั้งหมด

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

switch ($someoption) {
  case 'a':
  case 'b':
  case 'c':
    // Do something
    break;

  case 'd':
  case 'e':
    // Do something else
    break;
}

ลองนึกภาพการทำเช่นนี้กับ if / else มันจะวุ่นวาย

อาจมีประโยชน์มากไม่กี่ครั้ง แต่โดยทั่วไปแล้วพฤติกรรมที่ต้องการจะไม่ตก ควรอนุญาตให้ตกได้ แต่ไม่ใช่โดยปริยาย

ตัวอย่างในการอัปเดตเวอร์ชันเก่าของข้อมูลบางส่วน:

switch (version) {
    case 1:
        // Update some stuff
    case 2:
        // Update more stuff
    case 3:
        // Update even more stuff
    case 4:
        // And so on
}

ฉันชอบไวยากรณ์ที่แตกต่างกันสำหรับทางเลือกในสวิตช์บางอย่างเช่นผิดพลาด ..

switch(myParam)
{
  case 0 or 1 or 2:
    // Do something;
    break;
  case 3 or 4:
    // Do something else;
    break;
}

หมายเหตุ: สิ่งนี้จะเกิดขึ้นได้ด้วย enums ถ้าคุณประกาศทุกกรณีใน enum โดยใช้แฟล็กใช่ไหม? มันฟังดูไม่เลวเหมือนกัน กรณีนี้สามารถ (ควร?) เป็นส่วนหนึ่งของ enum ของคุณได้เป็นอย่างดี

บางทีนี่อาจเป็นกรณีที่ดี (ไม่มีการเล่นสำนวน) สำหรับอินเทอร์เฟซที่คล่องแคล่วโดยใช้วิธีการขยาย? บางสิ่งบางอย่างผิดพลาด ...

int value = 10;
value.Switch()
  .Case(() => { /* Do something; */ }, new {0, 1, 2})
  .Case(() => { /* Do something else */ } new {3, 4})
  .Default(() => { /* Do the default case; */ });

แม้ว่าอาจจะอ่านได้น้อยลงก็ตาม: P

เช่นเดียวกับสิ่งอื่น ๆ : หากใช้ด้วยความระมัดระวังอาจเป็นเครื่องมือที่สวยงาม

อย่างไรก็ตามฉันคิดว่ามีข้อเสียมากกว่าที่จะไม่ใช้มันและสุดท้ายก็ไม่อนุญาตอีกต่อไป (C #) ในบรรดาปัญหา ได้แก่ :

• การ "ลืม" การหยุดพักเป็นเรื่องง่าย
• ไม่ชัดเจนเสมอไปสำหรับผู้ดูแลรหัสว่าการหยุดพักที่ละเว้นนั้นเป็นเจตนา

การใช้สวิตช์ / เคสกันตกอย่างดี:

switch (x)
{
case 1:
case 2:
case 3:
 Do something
 break;
}

Baaaaad การใช้สวิตช์ / กรณีตกผ่าน:

switch (x)
{
case 1:
    Some code
case 2:
    Some more code
case 3:
    Even more code
    break;
}

สิ่งนี้สามารถเขียนใหม่ได้โดยใช้ if / else สร้างโดยไม่มีการสูญเสียเลยในความคิดของฉัน

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

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

ทุกที่ที่ฉันใช้ฉันมั่นใจว่ามีการแสดงความคิดเห็นอย่างถูกต้อง:

switch($var) {
    case 'first':
        // Fall-through
    case 'second':
        i++;
        break;
 }

การใช้ Fall-through เหมือนในตัวอย่างแรกของคุณนั้นถือว่าใช้ได้อย่างชัดเจนและฉันจะไม่ถือว่ามันเป็นการล้มเหลวอย่างแท้จริง

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

สิ่งนี้เทียบเท่ากับสิ่งที่เราทำในโครงการอวกาศไม่มากก็น้อยเมื่อมีคนต้องการละเมิดมาตรฐานการเข้ารหัสพวกเขาต้องยื่นขอการจ่ายยา (และฉันถูกเรียกให้ไปให้คำแนะนำเกี่ยวกับการพิจารณาคดี)

ฉันไม่ชอบswitchให้คำพูดของฉันตกไป - มันมีโอกาสผิดพลาดและอ่านยากเกินไป ยกเว้นอย่างเดียวคือเมื่อหลายcaseงบทุกคนทำว่าสิ่งเดียวกัน

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

ในบางกรณีการใช้ fall-through เป็นการกระทำของความเกียจคร้านในส่วนของโปรแกรมเมอร์ - พวกเขาสามารถใช้ชุดของ || ตัวอย่างเช่น แต่ใช้ชุดของกรณีสวิตช์ 'catch-all' แทน

ดังที่กล่าวมาฉันพบว่าพวกเขามีประโยชน์อย่างยิ่งเมื่อฉันรู้ว่าในที่สุดฉันก็ต้องการตัวเลือกอยู่ดี (เช่นในการตอบกลับเมนู) แต่ยังไม่ได้ใช้ตัวเลือกทั้งหมด ในทำนองเดียวกันหากคุณกำลังทำ Fall-through ทั้ง 'a' และ 'A' ฉันพบว่าการใช้สวิตช์ fall-through นั้นสะอาดกว่าการใช้คำสั่ง if

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

ควรใช้ Fall-through เฉพาะเมื่อใช้เป็นตารางกระโดดลงในบล็อกโค้ด หากมีส่วนใดส่วนหนึ่งของโค้ดที่มีการแบ่งโดยไม่มีเงื่อนไขก่อนที่จะมีกรณีมากกว่านี้กลุ่มเคสทั้งหมดควรจบลงด้วยวิธีนั้น

สิ่งอื่นใดคือ "ความชั่วร้าย"