Đã có một vài nhận xét về khoảng trắng đã được thảo luận về các vị trí niềng răng xoăn.

Bản thân tôi có xu hướng rắc mã của mình bằng các dòng trống trong nỗ lực phân tách những thứ đi cùng nhau trong các nhóm "hợp lý" và hy vọng giúp người tiếp theo dễ dàng đọc mã tôi vừa tạo.

Trong thực tế, tôi sẽ nói rằng tôi cấu trúc mã của mình giống như tôi viết: Tôi tạo các đoạn văn, không dài hơn một vài dòng (chắc chắn ngắn hơn 10) và cố gắng làm cho mỗi đoạn văn tự khép kín.

Ví dụ:

• trong một lớp, tôi sẽ nhóm các phương thức đi cùng nhau, trong khi tách chúng bằng một dòng trống từ nhóm tiếp theo.
• nếu tôi cần viết bình luận tôi thường đặt một dòng trống trước bình luận
• trong một phương thức, tôi tạo một đoạn văn cho mỗi bước của quy trình

Nói chung, tôi hiếm khi có hơn 4/5 dòng được nhóm lại với nhau, có nghĩa là một mã rất thưa thớt.

Tôi không coi tất cả khoảng trắng này là lãng phí vì tôi thực sự sử dụng nó để cấu trúc mã (thực tế là tôi sử dụng thụt đầu dòng), và do đó tôi cảm thấy nó xứng đáng với giá trị màn hình.

Ví dụ:

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

    array[i] += 2;
}

Tôi xem xét hơn hai tuyên bố có mục đích riêng biệt rõ ràng và do đó xứng đáng được tách ra để làm cho nó rõ ràng.

Vì vậy, làm thế nào để bạn thực sự sử dụng (hoặc không) các dòng trống trong mã?

Luôn luôn

Khoảng trắng là rất quan trọng để làm sạch mã có thể đọc được. Một dòng trống (hoặc hai) giúp phân tách trực quan các khối mã logic.

Ví dụ: từ Hoàn thành mã của Steve McConnell, Chương thứ hai về Bố cục và Phong cách:

Các đối tượng đạt điểm cao hơn từ 20 đến 30 phần trăm trong bài kiểm tra mức độ hiểu khi các chương trình có sơ đồ thụt hai đến bốn không gian so với khi các chương trình không có thụt đầu dòng.Nghiên cứu tương tự cho thấy điều quan trọng là không nhấn mạnh hoặc nhấn mạnh quá mức cấu trúc logic của chương trình. Điểm hiểu thấp nhất đã đạt được trên các chương trình hoàn toàn không thụt lề. Thấp nhất thứ hai đã đạt được trên các chương trình sử dụng thụt sáu không gian. Nghiên cứu kết luận rằng thụt hai đến bốn không gian là tối ưu. Thật thú vị, nhiều đối tượng trong thí nghiệm cảm thấy rằng vết lõm sáu không gian dễ sử dụng hơn so với các vết lõm nhỏ hơn, mặc dù điểm của họ thấp hơn. Đó có lẽ là do sáu vết lõm không gian trông đẹp mắt. Nhưng bất kể nó trông đẹp thế nào, vết lõm sáu không gian hóa ra lại ít đọc hơn. Đây là một ví dụ về sự va chạm được mười hai hấp dẫn thẩm mỹ và dễ đọc.

Vâng cho rõ ràng.

Giống như tôi đã làm trong câu trả lời này.

Tôi làm nhưng tôi chắc chắn rằng tôi làm tài liệu bằng cách đặt

(This line intentionally left blank.)

trên đường dây

Có, nhưng tôi không lạm dụng nó.

Tôi đã thấy mã trong đó mỗi dòng mã bên trong một phương thức được phân tách bằng một dòng trống và hai dòng trống được sử dụng khi xảy ra sự phân tách logic. Điều đó chỉ làm cho nó thậm chí ít đọc hơn theo ý kiến ​​của tôi. Tôi cũng đã thấy khoảng trắng được sử dụng để sắp xếp điên rồ, chẳng hạn như:

//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)
{
    ...
}

Việc lạm dụng cùng một khoảng trắng ngang có thể được áp dụng cho khoảng trắng dọc. Giống như bất kỳ công cụ, sử dụng nó một cách khôn ngoan.

Tôi bị chỉ trích rất nhiều vì đã viết mã theo cách này. Tôi không hiểu tại sao mọi người sẽ không làm theo cách này.

Khả năng đọc rất quan trọng khi bạn quay lại dự án sau một khoảng thời gian dài và tôi đã nghe một câu nói "Luôn viết mã nếu anh chàng tiếp theo đang đọc nó là một kẻ thái nhân cách biết vị trí của bạn".

Tôi không phải lúc nào cũng viết phần mềm, nhưng khi tôi làm, tôi sử dụng các dòng trống cho rõ ràng.

Tôi là tất cả để làm cho mã càng rõ ràng càng tốt và khoảng trắng thường là một công cụ hữu ích trong nỗ lực đó. Nhưng đừng quên tái cấu trúc:

• trong một lớp, tôi sẽ nhóm các phương thức đi cùng nhau, trong khi tách chúng bằng một dòng trống từ nhóm tiếp theo.

Vì bạn có một vài thành viên liên quan, họ là một ứng cử viên cho một lớp mới.

• nếu tôi cần viết bình luận tôi thường đặt một dòng trống trước bình luận

Bất cứ khi nào mã không đủ rõ ràng để muốn nhận xét, tôi hỏi liệu tôi có thể cấu trúc lại để làm cho mã đủ rõ ràng để không cần bình luận không.

• trong một phương thức, tôi tạo một đoạn văn cho mỗi bước của quy trình

Tại sao không tạo một phương thức cho mỗi "đoạn"?

Nếu bạn kết thúc với một loạt các phương thức trong lớp của bạn, hãy xem ghi chú của tôi ở trên về việc trích xuất một lớp mới.

Vâng. Nó làm cho nó dễ dàng hơn để quét một tập tin. Trong số những thứ khác, nó làm cho nó rõ ràng hơn dòng bình luận đi với.

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

Tôi sử dụng các dòng trống một cách tiết kiệm và nhất quán, và nhất quán là quan trọng hơn một cách tiết kiệm. Tuy nhiên:

• Nếu mỗi dòng mã được phân tách từ dòng tiếp theo bởi một dòng trống, có quá nhiều dòng trống.
• Nếu không có vần hay lý do nào dễ nhận thấy ở nơi đặt các dòng trống, thì chúng là một sự phân tâm và thường có quá nhiều trong số chúng.
• Nếu một hàm quá lớn đến mức nó cần nhiều dòng trống thì nó quá lớn.
• Nếu một khối mã cần nhiều hơn một dòng trống trước hoặc sau nó, có một cái gì đó sai lệch nghiêm trọng.
• Nếu bạn có nhiều hơn hai dòng trống giữa các hàm, có thể bạn có quá nhiều dòng trống.

Hầu hết trong số đó không gây tranh cãi khủng khiếp; những gì sau có thể được. Tôi lưu ý rằng ký hiệu K & R với dấu ngoặc nhọn ở cuối dòng thường bị theo sau bởi một dòng trống. Cá nhân tôi không thích niềng răng ở cuối dòng và trộn nó với một dòng trống sau khi niềng răng tạo ra một sự vô nghĩa của ký hiệu (IMNSHO). Đặt dấu ngoặc mở trên dòng tiếp theo, và bạn có một dòng hầu hết trống (và, IMNSHO, mã dễ đọc hơn). Nếu bạn phải sử dụng nẹp K & R ở cuối dòng, đừng lãng phí tiết kiệm không gian theo chiều dọc với các dòng trống bên ngoài.

// 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 ...

}

Viết đó là dễ đọc nhất và ít ngạc nhiên nhất.

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

Hàm này không cần 12 dòng bình luận doc.

Trong thực tế, nó không cần bất kỳ ý kiến.

Hoặc dòng trống.

Họ sẽ làm mất đi bản chất của nó.

Bên trong chức năng? Ít khi

Nếu tôi có một khối khác biệt rõ ràng thì đó là tái cấu trúc cho một chức năng mới. Nếu một vài trường hợp không xứng đáng.

Đối với tôi, các dòng trống bên trong hàm là một trong những "thực tiễn tốt nhất" sai nhất.

Thường

Sử dụng nó cho các khối mã logic được xử lý tương tự. Khi bạn thêm một nhận xét để cho thấy rằng bạn đang thực hiện một bước khác - đó là thời gian để Trích xuất phương pháp.

Khoảng trắng tốt

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

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

    setPosition(x, y);
}

Khoảng trắng xấu

{
    //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);        
}    

đấu với

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

đấu với

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

Tôi không chỉ sử dụng khoảng trắng, tôi còn sử dụng niềng răng cho rõ ràng.

Niềng răng tôi sử dụng để nói rằng chúng có thể có chức năng.

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

    code()
    code()
}

Có một lần, tôi sẽ tự do rắc các dòng trống trong toàn bộ mã của mình. Ngày nay, tôi có xu hướng tiết kiệm hơn. Tôi nghĩ rằng đây là một phần của những gì Steve Yegge đã nói về ở đây :

Hy vọng rằng cảnh tôi đã vẽ cho đến nay giúp bạn hiểu lý do tại sao đôi khi bạn nhìn vào mã và bạn chỉ ghét nó ngay lập tức. Nếu bạn là n00b, bạn sẽ xem mã có kinh nghiệm và nói rằng nó không thể xuyên thủng, vô kỷ luật được viết bởi một người không bao giờ học được những điều cần thiết của công nghệ phần mềm hiện đại. Nếu bạn là một cựu chiến binh, bạn sẽ xem mã n00b và nói rằng nó được bình luận quá mức, lông tơ trang trí mà một thực tập sinh có thể đã viết trong một đêm uống nhiều rượu.

Điểm dính là khả năng chịu nén. Khi bạn viết mã thông qua sự nghiệp của mình, đặc biệt nếu mã đó bao gồm các ngôn ngữ và miền vấn đề rất khác nhau, khả năng nén mã của bạn tăng lên. Không khác gì sự tiến bộ từ việc đọc sách thiếu nhi với văn bản khổng lồ đến tiểu thuyết ngày càng phức tạp với văn bản nhỏ hơn và từ lớn hơn.

...

Một lập trình viên có khả năng chịu nén cao thực sự bị cản trở bởi một màn kể chuyện. Tại sao? Bởi vì để hiểu một cơ sở mã, bạn cần có khả năng đóng gói càng nhiều càng tốt vào đầu. Nếu đó là một thuật toán phức tạp, một lập trình viên kỳ cựu muốn xem toàn bộ sự việc trên màn hình, điều đó có nghĩa là giảm số lượng dòng trống và nhận xét nội tuyến - đặc biệt là các nhận xét chỉ đơn giản nhắc lại những gì mã đang làm. Điều này hoàn toàn ngược lại với những gì một lập trình viên n00b muốn. n00bs muốn tập trung vào một tuyên bố hoặc biểu thức tại một thời điểm, di chuyển tất cả các mã xung quanh nó ra khỏi tầm nhìn để họ có thể tập trung, phát ra tiếng kêu lớn.

Tôi cơ bản đồng ý với anh ta. Sẽ tốt hơn nhiều khi nén mã để bạn có thể lấy càng nhiều mã càng tốt trên một màn hình hơn là để trống quá nhiều. Điều đó không có nghĩa là bạn không bao giờ nên sử dụng các dòng trống. Chỉ là tôi nghĩ trừ khi việc nhóm bạn đang cố gắng tạo ra không làm tăng khả năng đọc vô cùng, nó sẽ gây hại nhiều hơn là tốt.

Một giáo sư danh dự đã đưa ra hai lời khuyên tuyệt vời

1. Khoảng trắng là miễn phí
2. Đừng sử dụng các mặt hàng chủ lực chọc ngược lên phía trước tờ giấy, nếu không tôi sẽ làm bạn thất vọng.

Quy tắc của tôi là:

1. Nếu tôi gặp khó khăn khi đọc mã tôi đã viết ngày hôm qua, có lẽ tôi cần trích xuất một hoặc ba phương thức.

2. Nếu định nghĩa lớp của tôi quá dài để đọc dễ dàng, có lẽ tôi cần trích xuất một mô-đun / giao diện / đối tượng.

3. Định nghĩa phương thức: thêm một dòng

4. Định nghĩa mô-đun / lớp: thêm hai dòng

Tôi thích nghĩ về khoảng trắng giống như đoạn văn. Bạn nhóm các dòng lại với nhau đóng góp cho một ý tưởng.

Nếu bạn đang bắt đầu một ý tưởng mới hoặc một khía cạnh mới của cùng một ý tưởng, bạn bắt đầu một đoạn mới - như thế này.

Trong mã bắt buộc, tôi nhóm các nhiệm vụ thực hiện một nhiệm vụ gắn kết; trong mã khai báo, tôi nhóm các mã lại với nhau để mô tả một tuyên bố gắn kết của một ý tưởng.

Bạn rõ ràng không gặp khó khăn gì khi làm điều đó bằng tiếng Anh (một số người rất kinh khủng với đoạn văn), vì vậy với một chút luyện tập, áp dụng cùng một kỹ năng vào mã nên không có gì khó khăn cả.

Theo tôi, các dòng trống là phải. Tôi sử dụng chúng để phân tách các khối mã logic khác nhau. Làm cho mã có thể đọc được. Mã dễ đọc là mã tốt;)

Đoạn mã lý tưởng của tôi sẽ là mỗi khối logic được phân tách bằng một dòng trống và một nhận xét trên đầu mỗi khối có logic chính.

Tất nhiên, nếu mọi người làm điều đó bằng cách thêm nhiều dòng trống ở khắp mọi nơi, tôi thấy điều đó rất khó chịu :(

Tôi chỉ sử dụng khoảng trắng trong một hàm / phương thức để phân tách khai báo và mã.

Nếu bạn cảm thấy cần phải có một số dòng để tách các khối mã con thực hiện một số logic, thì chúng nên nhưng trong một phương thức hàm / riêng khác. Tùy thuộc vào trình biên dịch của bạn để không làm cho quá lớn.

thông thường, trong mã peusdo:

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

    CODE
    BLOCK_START
        INITIALIZERS

        CODE
    BLOCK_END
    CODE
end

Nếu tôi thấy khoảng trắng vô dụng, tôi thường co rúm lại.

Không gian màu trắng vô cùng quý giá.

Đây là thỏa thuận ... những người viết mã phức tạp như E = MC ² rất tuyệt trong việc thể hiện các kỹ năng lập trình của họ.

Bây giờ, hãy nhảy lên trước sáu tháng, và đó là 2:00 sáng và hệ thống chưa được xem xét trong sáu tháng đã bị hỏng trên chính dòng E = MC ² . Điều này gần như không thể gỡ lỗi ... tất cả mọi người đang hoảng loạn.

Giả sử mã trông giống như thế này ...

See Dick
See Jane
See Dick and Jan

Nếu đó là 2:00 sáng và mã bị hỏng. Nhìn lướt qua sẽ cho bạn thấy rằng dòng ba nên có

See Dick and Jane

Vấn đề được giải quyết.

Dòng dưới cùng ... sử dụng khoảng trắng.

Như nhiều người khác đã nêu, các dòng trống giúp đọc mã dễ dàng hơn. Tuy nhiên, có một số ngôn ngữ thực thi tiêu chuẩn này. Một thứ mà tôi có thể nghĩ ra khỏi đỉnh đầu (không quá nhiều về các dòng trống nhưng thụt lề thích hợp) là Python.

Tôi đồng ý, tôi sử dụng khoảng trắng theo cùng một cách. Tuy nhiên, nếu tôi thấy mình sử dụng khoảng trắng để chia một phương thức thành quá nhiều phần, đó là dấu hiệu tôi có thể cần phải cấu trúc lại mã đó thành nhiều phương thức. Quá nhiều phần logic trong một phương thức có thể báo hiệu rằng phương thức đó sẽ khó kiểm tra hơn.

Tôi sử dụng chúng để phân tách mã thành các đơn vị logic. Tôi đã thấy rất ít mẫu mã không sử dụng các dòng trống, tất nhiên là loại bỏ mã hóa.

Câu trả lời của Psychopath là tốt nhất, nhưng tôi sẽ thay thế bằng giả định rằng người tiếp theo là một thằng ngốc, và họ sẽ cho rằng bạn là như vậy, và bạn sẽ muốn chứng minh họ sai.

Cũng quan trọng đối với khả năng đọc là việc sử dụng các ý kiến. Tôi mở từng hàm hoặc chương trình con với một khối nhận xét, giải thích bằng văn bản rõ ràng, nó là gì, nó làm gì, các đối số là gì và kết quả mong đợi là gì (bao gồm cả danh sách các điều kiện lỗi). Sau đó, không có câu hỏi về những gì nó được dự định và / hoặc được thiết kế để làm. Những gì nó đạt được có thể khác nhau, nhưng đó là xa hơn theo dõi.

Tôi nghĩ rằng có quá nhiều lập trình viên cho rằng chính họ sẽ thực hiện "sửa chữa" mã, hoặc đơn giản là không quan tâm.

Dòng trống là quan trọng. Tuy nhiên, lãng phí toàn bộ một dòng trống trên dấu ngoặc mở làm giảm số lượng mã bạn có thể nhìn thấy trong một màn hình. Nên là:

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

   array[i] += 2;
}

(Đừng để tôi bắt đầu đặt niềng răng '{' trên cùng một dòng với 'cho' ... đó là lướiuggah).

Vâng. Để dễ đọc. Đôi khi tôi thậm chí đặt các dòng trống trong mã mà tôi đã không viết. Tôi thấy việc hiểu mã dễ dàng hơn khi họ có nhóm logic thông qua các dòng trống - như bạn có thể "đọc tốc độ" thông qua nó.

Chúng ta nên sử dụng các dòng trống giữa các codeblocks như chúng ta làm khi chúng ta viết một lá thư.

Ví dụ: giữa các hàm hoặc bên trong một hàm khi chúng ta hoàn thành một vòng lặp ...

Mọi người sẽ cảm ơn bạn một mã sạch nếu họ phải bảo trì nó;)

Chúng tôi sử dụng khoảng trắng được đề xuất bởi Microsoft StyleCop. Ngoài khả năng đọc và tính nhất quán, tôi thấy rằng (cùng với quy mô lớp nhỏ) được đặt đúng mã giúp quản lý việc hợp nhất dễ dàng hơn khi nhiều người trong một nhóm tình cờ làm việc trên cùng một khu vực.

Tôi không chắc đó chỉ là trí tưởng tượng của mình nhưng các công cụ khác biệt dường như làm tốt hơn việc nhận ra nơi mã tương đương bắt đầu và kết thúc khi hợp nhất khi nó được đặt gọn gàng. Mã đặt ra độc đáo là một niềm vui để hợp nhất. Ok, đó là một lời nói dối - nhưng ít nhất nỗi đau được giữ ở mức có thể kiểm soát được.

Không bao giờ là một dòng trống, không phải trong toàn bộ tập tin. Điều đó không có nghĩa là không có vi phạm trong mã:

 code;
 //
 morecode;

Các dòng trống là để mở các phần của mã để làm việc, bạn có một vài phím nóng trong trình soạn thảo để đưa bạn đến dòng trống trước / tiếp theo.