คำสั่งเดียวถ้าบล็อก - วงเล็บหรือไม่? [ปิด]

ข้อไหนดีกว่า / ยอมรับโดยทั่วไปมากกว่า

นี้:

if(condition)
{
  statement;
}

หรือ:

if(condition)
  statement;

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

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

if(condition) 
//      statement;
otherStatement;

หรือเพิ่มรหัสอย่างรวดเร็ว:

if(condition) 
    statement;
    otherStatement;

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

if(condition) statement;

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

ฉันมักจะใช้วงเล็บเพื่อความปลอดภัย

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

ฉันชอบเวอร์ชันที่ไม่มีเครื่องหมายปีกกามากที่สุด

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

(ใกล้ -) บรรทัดว่างเปล่าเป็นของเสีย

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

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

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

นี่เป็นปัญหาพื้นฐาน : เมื่อคุณไม่เห็นบล็อกทั้งหมดบนหน้าจออีกต่อไปมันจะซับซ้อนเกินกว่าที่จะเข้าใจ

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

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

การละเว้นการจัดฟันอาจไม่เป็นอันตราย

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

นี่จะเป็นเรื่องใหญ่แน่ ๆ

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

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

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

ดังนั้นจนกว่าจะมีใครสามารถแสดงข้อมูลที่ฉันเก็บรวบรวมจากการทดลองทางวิทยาศาสตร์แสดงให้เห็นว่านี่เป็นปัญหาในทางปฏิบัติจริง ๆ แล้วทฤษฎีนี้ยังคงเป็น " เรื่องราวที่ดีมาก": สมมติฐานที่น่าสนใจอย่างมากที่ไม่เคยถูกทดสอบ ต้องไม่ใช้เป็นอาร์กิวเมนต์

¹บางครั้งปัญหานี้ได้รับการแก้ไขโดยการใส่ทุกอย่าง - รวมทั้งเครื่องหมายปีกกา - ในบรรทัดเดียวกัน:

if (condition)
{ do_something(); }

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

ฉันไปกับที่สอง มันกระชับและ verbose น้อยกว่า

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

ฉันจะใช้ต่อไปนี้ (ฉันทามติที่นี่):

if (condition) {
    any_number_of_statements;
}

เป็นไปได้:

if(condition) single_compact_statement;

ไม่ค่อยดีนักโดยเฉพาะใน C / C ++ - เช่นภาษา:

if(condition) 
    single_compact_statement;

(ไม่มีตัวเลือกที่นี่ในPython ;-)

ในPerlคุณจะใช้:

$C = $A**3 if $A != $B;

หรือ

$C = $A**3 unless $A == $B;

(นี่ไม่ใช่ pseudocode ;-)

ฉันใช้วิธีการจัดฟัน - ด้วยเหตุผลทั้งหมดข้างต้นบวกอีกหนึ่งข้อ

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

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

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

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

หากคุณต้องการเพิ่มรหัสในifบล็อกคุณไม่จำเป็นต้องจำ / ค้นหาการจัดฟัน เมื่อโปรแกรมเมอร์ในอนาคตอ่านโค้ดเครื่องมือจัดฟันจะไม่คลุมเครือเสมอ

ในด้านบวกReSharperจะเพิ่มวงเล็บปีกกาสำหรับโปรแกรมเมอร์ที่ขี้เกียจใน Visual Studio และฉันคิดว่ามี addons สำหรับIDEอื่น ๆที่จะทำเช่นนั้น

ฉันใช้ไวยากรณ์แรกเกือบจะไม่มีข้อยกเว้น เพราะมันไม่สามารถถูกตีความผิด

"อย่าทำให้ฉันคิดว่า" ไม่ได้ใช้กับส่วนต่อประสานกับผู้ใช้เท่านั้น y'all ;-)

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

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

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

if (condition) {
    statement;
} // stupid extra brace looks ugly

แล้วก็

if (condition) // the brackets have now just become noise
{ statement; } // also can't see the indentation, harder to read

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

ฉันใช้เวอร์ชันสองบรรทัดโดยไม่มีเครื่องหมายปีกกา (แบบฟอร์ม 2) แต่ไม่ประหยัดพื้นที่

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

ถ้าฉันใช้แบบฟอร์มนี้ฉันต้องแน่ใจว่ามีบรรทัดว่าง (หรือบรรทัดที่มีวงเล็บปีกกาเท่านั้น) ก่อนและหลังifคำสั่ง (หรือเหนือความคิดเห็นหากมี) แม้ว่านี่จะไม่ใช่กฎที่ฉันทำตามอย่างมีสติ แต่ฉันก็สังเกตเห็นได้ทันทีหลังจากอ่านคำถามนี้

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

ด้านล่างนี้เป็นตัวอย่างบางส่วนที่แสดงให้เห็นว่าฉันใช้รูปแบบของifคำชี้แจงนี้ได้อย่างไร

    string GuardConditions(Plan planForWorldDomination)
    {
        if (planForWorldDomination == null)
            throw new ArgumentNullException("planForWorldDomination");

        if (!planForWorldDomination.IsComplete())
            return "Doh!";

        planForWorldDomination.Execute();
    }

    void ProcessingLogic()
    {
        OneBlankLineAbove();

        if (simpleCondition)
            simpleStatement();

        OneBlankLineBelow();
        OneBlankLineAbove();

        // optional comment on the line above an if statement
        if (simpleCondition)
            simpleStatement();

        OneBlankLineBelow();
    }

    void Assignment(string drive)
    {
        OneBlankLineAbove();

        string prompt;
        if (simpleCondition)
            prompt = "simple assignment";
        else
            prompt = null;

        OneBlankLineBelow();
    }

    string Return()
    {
        OneBlankLineAbove();

        if (simpleCondition)
            return "simple return";
        else
            return null;

        OneBlankLineBelow();
    }

วงเล็บปีกกา เสมอ. ฉันเป็นแฟนของพวกเขาเพราะมันให้รหัสที่แน่นอน และเช่นเดียวกับ @dsimcha wrote - โอกาสน้อยสำหรับข้อผิดพลาดในการเพิ่มบรรทัดของรหัสเพิ่มเติม

"Uginess" ของการจัดฟันรอบรหัสบรรทัดเดียวมีอันตรายน้อยกว่างานเพิ่มเติมซึ่งเป็นไปได้ในกรณีเหล่านั้นด้วยการดีบักและ / หรือการเพิ่มรหัส

ส่วนตัวฉันไปกับวงเล็บ

ทำไม?

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

มันเก็บรูปแบบของifข้อความที่สอดคล้องกันไม่ว่าจะมีกี่ประโยคในบล็อก

อย่างไรก็ตามถ้าสไตล์ของโครงการเป็นไปโดยไม่ติดไปที่

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

if (x==5) Console.WriteLine("It's a five!");

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

If (cond) { statement; }

ฉันมักจะใช้เครื่องมือจัดฟัน แต่มีบางกรณีที่ฉันไม่ได้

object GetObject() {
    // calculate obj1
    if(obj1 != null)
        return obj1;

    // calculate obj2
    if(obj2 != null)
        return obj2;

    // calculate obj3
    if(obj3 != null)
        return obj3;

    return defaultObj;
}

สำหรับฉันมันแค่โง่ ๆ ที่จะเพิ่มเข้าไปในนั้น หากมีคนเพิ่มคำสั่งหลังจากreturnนั้นเรามีปัญหาที่ใหญ่กว่าปัญหาการกำหนดขอบเขต

หาก IDE มีการจัดรูปแบบโค้ดที่มีอยู่ฉันไม่ได้ใช้เครื่องมือจัดฟัน

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