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

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

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

ตัวอย่างเช่น:

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

โดยรวมแล้วฉันไม่ค่อยมีกลุ่มมากกว่า 4/5 บรรทัดรวมกันซึ่งหมายถึงโค้ดที่กระจัดกระจายมาก

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

ตัวอย่างเช่น:

for (int i = 0; i < 10; ++i)
{
    if (i % 3 == 0) continue;

    array[i] += 2;
}

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

ดังนั้นคุณจะใช้บรรทัดว่างเปล่า (หรือไม่) ในรหัสได้อย่างไร

เสมอ

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

ตัวอย่างเช่นจากCode Complete ของ Steve McConnellบทที่สองในเค้าโครงและสไตล์:

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

ใช่เพื่อความชัดเจน

เหมือนที่ฉันทำในคำตอบนี้

ฉันทำ แต่ฉันแน่ใจว่าฉันบันทึกไว้

(This line intentionally left blank.)

ในบรรทัด

ใช่ แต่ฉันไม่ได้ละเมิด

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

//Prot.   Return type                    Name                 Arg1        Arg2
//=====   ============================== ==================== =========== ========

private   int                            AMethodWithALongName(string s,   object o)
{
    ...
}

private   IDictionary<MyLongObject, int> SomethingCrazy      (string s)
{
    ...
}

protected void                           Foo                 (string str, object o)
{
    ...
}

การใช้พื้นที่สีขาวในแนวนอนในทางเดียวกันสามารถนำไปใช้กับพื้นที่สีขาวในแนวตั้งได้ เช่นเดียวกับเครื่องมือใด ๆ ให้ใช้อย่างชาญฉลาด

ฉันถูกวิพากษ์วิจารณ์อย่างมากจากการเขียนโค้ดด้วยวิธีนี้ ฉันไม่เข้าใจว่าทำไมไม่มีใครทำแบบนี้

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

ฉันไม่ได้เขียนซอฟต์แวร์เสมอไป แต่เมื่อฉันทำฉันจะใช้บรรทัดว่างเพื่อความชัดเจน

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

• ในชั้นเรียนฉันจะจัดกลุ่มวิธีการที่ไปด้วยกันในขณะที่แยกพวกเขาด้วยบรรทัดว่างจากกลุ่มถัดไป

เนื่องจากคุณมีสมาชิกที่เกี่ยวข้องหลายคนพวกเขาจึงเป็นผู้สมัครในชั้นเรียนใหม่

• ถ้าฉันต้องการเขียนความคิดเห็นฉันมักจะใส่บรรทัดว่างไว้ข้างหน้าความคิดเห็น

เมื่อใดก็ตามที่รหัสไม่ชัดเจนพอที่จะต้องการความคิดเห็นฉันถามว่าฉันสามารถ refactor เพื่อให้รหัสชัดเจนเพียงพอที่จะไม่ต้องการความคิดเห็น

• ในวิธีการฉันทำหนึ่งย่อหน้าต่อขั้นตอนของกระบวนการ

ทำไมไม่ทำหนึ่งวิธีสำหรับ "วรรค" แต่ละอัน?

หากคุณจบด้วยวิธีการมากมายในชั้นเรียนของคุณดูบันทึกย่อของฉันด้านบนเกี่ยวกับการแยกคลาสใหม่

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

Some code here
// Which line does this comment go with?
More code here

// It's pretty clear which line this comment goes with
More code here

Still more code here

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

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

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

// I don't like this
if (something == anotherthing) {
    print ...
    update ...
}

// I much prefer this
if (something == anotherthing)
{
    print ...
    update ...
}

// I loathe this - not least for its inconsistent spacing
if (something == anotherthing) {

    print ...
    update ...
}

// I loathe this too, for its absurd waste of vertical space
if (something == anotherthing) {

    print ...
    update ...

}

เขียนสิ่งที่ชัดเจนที่สุดและน่าประหลาดใจที่สุด

function validEmail($addr) {
    $regex = "/.../";   
    return preg_match($regex, $addr);
}

ฟังก์ชั่นนี้ไม่ต้องการความคิดเห็นเอกสาร 12 บรรทัด

ที่จริงแล้วมันไม่ต้องการความคิดเห็นใด ๆ

หรือบรรทัดว่างเปล่า

พวกเขาจะเบี่ยงเบนจากสาระสำคัญ

ข้างในฟังก์ชั่น? ไม่ค่อยมี

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

สำหรับฉันช่องว่างภายในฟังก์ชั่นเป็นหนึ่งใน "แนวทางปฏิบัติที่ดีที่สุด" ที่ผิด

บ่อยครั้ง

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

ช่องว่างที่ดี

{
    int x = computeX();
    x += ADJUSTMENT_FACTOR_X;

    int y = computeY();
    y += ADJUSTMENT_FACTORY_Y;

    setPosition(x, y);
}

ช่องว่างที่ไม่ดี

{
    //Open a connection
    String serverAddress = lookupAddress();
    Connection connection = openConnection(serverAddress);
    connection.login(user, password);


    //Go get stuff from the server
    item1 = connection.get(1);
    item2 = connection.get(2);

    //Close connection
    connection.close();

    //log data
    log(item1);
    log(item2);

    //Update client
    gui.updateView(item1, item2);        
}    

VS

{
    Connection connection = openConnection();
    updateData(connection);
    closeConnection(connection);
    logUpdate();
    updateGui();
}

VS

{
     updateDataFromServer();
     logUpdate();
     updateGui();
}

ไม่เพียง แต่ฉันใช้ช่องว่างเท่านั้นฉันใช้วงเล็บปีกกาเพื่อความชัดเจน

การจัดฟันที่ฉันใช้เพื่อบอกว่าสิ่งเหล่านี้อาจเป็นฟังก์ชั่นได้

code
{
    code
    code
    code
    code
}
{
    code
    code=code
    code
    code

    code()
    code()
}

ในครั้งเดียวฉันจะโรยบรรทัดว่าง ๆ ตามรหัสของฉัน ทุกวันนี้ฉันมีแนวโน้มที่จะประหยัดมากขึ้น ฉันคิดว่านี่เป็นส่วนหนึ่งของสิ่งที่ Steve Yegge พูดถึงที่นี่ :

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

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

...

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

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

ศาสตราจารย์กิตติคุณให้คำแนะนำที่ยอดเยี่ยมสองชิ้น

1. ช่องว่างฟรี
2. อย่าใช้ลวดเย็บกระดาษที่โผล่ขึ้นมาทางด้านหน้าของกระดาษไม่เช่นนั้นฉันจะทำผิดพลาด

กฎของหัวแม่มือคือ:

1. หากฉันมีปัญหาในการอ่านรหัสที่ฉันเขียนเมื่อวานนี้ฉันอาจต้องแยกวิธีหรือสามวิธี

2. ถ้าคำจำกัดความของคลาสของฉันอ่านนานเกินไปฉันอาจต้องแยกโมดูล / อินเตอร์เฟส / วัตถุ

3. คำจำกัดความวิธีการ: เพิ่มบรรทัด

4. นิยามโมดูล / คลาส: เพิ่มสองบรรทัด

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

หากคุณกำลังเริ่มต้นแนวคิดใหม่หรือแง่มุมใหม่ของความคิดเดียวกันคุณเริ่มย่อหน้าใหม่ - เช่นนี้

ในรหัสที่จำเป็นฉันจัดกลุ่มงานที่ทำภารกิจหนึ่ง ในรหัสการประกาศฉันจัดกลุ่มโค้ดที่อธิบายคำสั่งที่ยึดติดกันของแนวคิด

คุณไม่มีปัญหาในการทำอย่างชัดเจนในภาษาอังกฤษ (บางคนน่ากลัวด้วยย่อหน้า) ดังนั้นด้วยการฝึกฝนเล็ก ๆ น้อย ๆ การใช้ทักษะเดียวกันกับการเขียนโค้ดไม่ควรยืดออกเลย

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

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

แน่นอนว่าถ้าผู้คนทำเช่นนั้นโดยเพิ่มบรรทัดว่างหลายบรรทัดทุกที่ฉันพบว่ามันน่ารำคาญมาก :(

ฉันใช้ช่องว่างภายในฟังก์ชัน / วิธีเพื่อแยกการประกาศและรหัสเท่านั้น

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

โดยทั่วไปใน peusdo-code:

def function(arg1, argn, ...)
    INITIALIZERS

    CODE
    BLOCK_START
        INITIALIZERS

        CODE
    BLOCK_END
    CODE
end

ถ้าฉันเห็นช่องว่างที่ไร้ประโยชน์ฉันมักจะประจบประแจง

พื้นที่สีขาวมีค่าอย่างยิ่ง

นี่คือข้อตกลง ... nerds ที่เขียนโค้ดที่ซับซ้อนเช่นE = MC ²นั้นยอดเยี่ยมในการแสดงทักษะการเขียนโปรแกรมของพวกเขา

ตอนนี้ขอกระโดดไปข้างหน้าหกเดือนและมันเป็น 02:00 ในตอนเช้าและระบบที่ไม่ได้รับการมองในหกเดือนได้หักบนเส้นมากE = MC 2 เกือบเป็นไปไม่ได้เลยที่จะทำการดีบั๊ก ... ทุกคนต่างหวาดผวา

สมมติว่ารหัสดูเหมือนมากกว่านี้ ...

See Dick
See Jane
See Dick and Jan

หากเป็น 02:00 น. และรหัสถูกทำลาย อย่างรวดเร็วจะแสดงให้คุณเห็นว่าบรรทัดที่สามควรจะเป็น

See Dick and Jane

แก้ไขปัญหา.

Bottom Line ... ใช้ช่องว่าง

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

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

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

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

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

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

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

for (int i; i < 10; ++i)
{  if (i % 3 == 0) continue;

   array[i] += 2;
}

(อย่าให้ฉันเริ่มวางวงเล็บ '{' ลงในบรรทัดเดียวกับ 'สำหรับ' ... นั่นคือ meshuggah)

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

เราควรใช้บรรทัดว่างระหว่าง codeblocks เช่นเดียวกับเมื่อเราเขียนจดหมาย

ตัวอย่างเช่นระหว่างฟังก์ชั่นหรือภายในฟังก์ชั่นเมื่อเราเสร็จสิ้นลูป ...

คนจะขอบคุณรหัสสะอาดถ้าพวกเขาต้องทำการบำรุงรักษามัน;)

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

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

ไม่มีบรรทัดว่างเปล่าที่จะไม่อยู่ในไฟล์ทั้งหมด ที่ไม่ได้บอกว่าไม่มีการแบ่งในรหัส:

 code;
 //
 morecode;

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