การบำรุงรักษาอย่างชาญฉลาดมีอีกอย่างหนึ่งที่ไม่ต้องใช้เครื่องมือจัดฟันที่ปลอดภัยหรือไม่?

คือelse whileโดยไม่แทรกแซงการพิจารณาการจัดฟัน "ปลอดภัย" การบำรุงรักษาที่ชาญฉลาด?

กำลังเขียนif-elseโค้ดโดยไม่มีเครื่องหมายวงเล็บด้านล่าง ...

if (blah)
    foo();
else
    bar();

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

อย่างไรก็ตามด้านล่างมีความเสี่ยงหรือไม่

if (blah)
{
    ...
}
else while (!bloop())
{
    bar();
}

หรือelse whileโดยไม่ต้องจัดฟันจัดฟันถือว่า "ปลอดภัย"?

ที่ทำให้ฉันรหัสนี้:

if ( ... ) try {
..
} catch (Exception e) {
..
} else {
...
}

ทุกครั้งที่คุณรวมบล็อกสองประเภทลืมการจัดฟันและไม่เพิ่มการเยื้องคุณจะสร้างโค้ดยากมากที่จะเข้าใจและบำรุงรักษา

อาจเป็นเพราะฉันได้เรียนรู้การค้าของฉัน (ย้อนกลับไปเมื่อใด) โดยใช้วิธีแจ็กสัน Entity โครงสร้างไดอะแกรมแต่ฉันสมัครสมาชิกเพื่อดูว่าคำ unbraced ที่ถูกต้องเพียงอย่างเดียวหลังจากifหรือelseเป็นต่อมาif(เช่นการอนุญาตให้else ifบันได)

สิ่งอื่นใด (ไม่มีการเล่นสำนวนเจตนา) ทำให้เกิดความเข้าใจผิดและ / หรือปัญหาการบำรุงรักษา นั่นคือสิ่งสำคัญของแนวคิด OPs ที่เป็น "ไม่ปลอดภัย"

ฉันยังต้องระมัดระวังมากเกี่ยวกับการรวมwhile()บรรทัดเดียวกันกับelse- ไม่ว่าจะค้ำยันหรือไม่ มันไม่ถูกต้องสำหรับฉัน ... การขาดมาสก์ย่อหน้าพิเศษที่เป็นส่วนelseคำสั่ง และการขาดความชัดเจนทำให้เกิดความเข้าใจผิด (ดูด้านบน)

ดังนั้นในตัวอย่างฉันขอแนะนำ / แนะนำ (และยืนยันในทีมของฉัน) ใน:

if ( blah )
{
    ...
}
else
{
    while ( !bloop() )
    {
        bar();
    }
}

แน่นอนฉันก็คาดหวังที่จะเห็นความคิดเห็นที่เหมาะสมเช่นกัน

- แก้ไข -

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

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

    if(blah)
    {
     ....
    }
    else
    {
       while(!bloop()
       {
        bar;
       }
    }

ฉันจะแยกวิธีการและทำให้มัน

if ( blah )
{
    ...
}
else
{
   newMethod();
}

ดูวิธีการ "แยกวิธี" ที่อธิบายไว้ในไซต์Refactoring Catalog

คุณมีส่วนของรหัสที่สามารถจัดกลุ่มเข้าด้วยกัน

เปลี่ยนแฟรกเมนต์เป็นวิธีที่ชื่ออธิบายถึงวัตถุประสงค์ของเมธอด

void printOwing() {
    printBanner();

    //print details
    System.out.println ("name:    " + _name);
    System.out.println ("amount    " + getOutstanding());
}

                                                                                                        

void printOwing() {
    printBanner();
    printDetails(getOutstanding());
}

void printDetails (double outstanding) {
    System.out.println ("name:    " + _name);
    System.out.println ("amount    " + outstanding);
}

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

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

if ( blah )
{
    ...
}
else
{
    while ( !bloop() )
    {
        bar();
    }
}

เป็นวิธีปฏิบัติที่ดีในการใส่รหัสในบล็อก ทำให้ง่ายต่อการเข้าใจและแก้ปัญหาเช่นกัน

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

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

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

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

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

if (...)
   foo();
else while(...)
   bar();

... ฉันพบว่า "" นี้else while(...)อ่านง่ายมาก! มันอ่านเหมือนภาษาอังกฤษธรรมดา ๆ ! แต่ฉันคิดว่าทุกคนจะพบว่ามันแปลกเพราะมันผิดปกติที่จะพูดน้อย

ในท้ายที่สุดเราทุกคนมักจะทำให้มันงี่เง่าพิสูจน์ด้วยวงเล็บปีกกาแม้ว่า ... เพราะคุณรู้

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

if(blah) {
    foo();
}
else {
    bar();
}

มีอะไรผิดปกติกับเครื่องมือจัดฟันที่ผู้คนจำนวนมากพยายามหลีกเลี่ยงการเขียนมัน?

ปัญหาอะไรกันแน่ที่else whileแก้ได้?

เครื่องมือจัดฟันนั้นมีราคาถูกและดีและพวกเขาทำให้ความตั้งใจของรหัสชัดเจนและตรงข้ามกับความฉลาดและไหวพริบ

การอ้างอิงปรัชญา Unix:

กฎของความชัดเจน: ความชัดเจนดีกว่าความฉลาด

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

ไม่มีอะไรผิดปกติกับ

if (blah)
    foo();
else
    bar();

เหมือนไม่มีอะไรผิดปกติ

if (blah) foo(); else bar();

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

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

นอกจากนี้ฉันเคยเห็นรหัสนี้มาก่อน:

if (x) foo()
{
  bar();
}

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

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

if (blah) {
  blub();
} else
  while (!bloop()) {
    bar();
  }

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

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

if (blah) blub();
else while (!bloop()) bar();

แต่แน่นอนว่านักพัฒนาจำนวนมากยินดีที่จะโต้แย้งเกี่ยวกับสิ่งต่าง ๆ เช่นนี้ตลอดไปและต่อวัน