Ngắt dòng trước / sau toán tử [đóng]

Trong khi quy ước mã Java của Sun đề nghị đặt ngắt dòng trước toán tử, nhiều hướng dẫn khác không đồng ý với nó. Tôi không thấy bất kỳ ưu và nhược điểm rõ ràng nào, vậy có lợi thế nào khi sử dụng một trong những phong cách này so với phong cách khác không?

String longVarName = a + b + c + d +
          e + f;

đấu với

String longVarName = a + b + c + d
          + e + f;

Tôi sẽ để nó trên một dòng và suy nghĩ về khả năng đọc về các tên biến và chức năng tiết lộ ý định.

Một khi nó trở nên lộn xộn, đã đến lúc tái cấu trúc :

• đổi tên vars
• giới thiệu vars / chức năng mới

Thí dụ

subtotal = price * (100 + tax_ratio) / 100`

so với

tax = price * tax_ratio / 100
subtotal = price + tax

Tôi có thể tưởng tượng khả năng đọc là một đối số

result = longidentifier +
   short -
   alittlelonger -
   c;

đấu với

result = longidentifier
   + short
   - alittlelonger
   - c;

Trong ví dụ thứ hai, các toán tử được xếp hàng độc đáo và bạn có thể dễ dàng nhìn thấy dấu hiệu nào mà biến được đưa vào phương trình. Tôi nghĩ rằng điều này cũng có ý nghĩa đối với các toán tử nhị phân, nhưng với giằng, v.v., bạn chỉ nên làm bất cứ điều gì rõ ràng hơn.

Tôi thường làm theo các hướng dẫn phong cách được sử dụng phổ biến nhất hoặc một công cụ tiêu chuẩn mã hóa nhất định. Lợi thế của việc sử dụng một kiểu được sử dụng phổ biến mang lại lợi ích khi bạn đang đọc mã của người khác hoặc tham gia vào một dự án nguồn mở nơi đặt ra các nguyên tắc về kiểu dáng.

Các phong cách phổ biến nhất mà tôi đã thấy là phong cách thứ hai trong câu hỏi. Xem dưới đây cho danh sách của họ:

Hướng dẫn về Phong cách của Google :

Khi một dòng bị hỏng tại một toán tử không gán, ngắt xuất hiện trước ký hiệu.

Công ước mã hóa mặt trời :

Phá vỡ trước một nhà điều hành

Toán tử kiểm tra Kiểu quấn Giá trị mặc định của kiểm tra là nl:

Toán tử phải ở trên một dòng mới

Trong mã tôi có xu hướng đặt dấu ngắt sau toán tử:

foo = some_long_expression() +
      some_other_long_expression();

Ở đây, toán tử treo lủng lẳng ở cuối dòng là một đầu mối lớn cho người đọc rằng mã tiếp tục. Trong các ngôn ngữ không có bộ kết thúc câu lệnh, toán tử lơ lửng đó có thể đóng vai trò là đầu mối đủ cho trình biên dịch / trình thông dịch mà mã tiếp tục (nếu không tôi sẽ phải sử dụng một số cấu trúc dòng tiếp tục xấu xí).

Khi ghi lại biểu thức đó (nếu nó cần tài liệu), tôi có xu hướng đặt dấu ngắt trước toán tử.

Miễn là bạn vẫn kiên định, thì biết rằng cũng không có lợi thế thực sự. Điều này đặc biệt quan trọng khi xem xét hợp nhất mã và khoảng trắng.

Tôi tin rằng dòng nên bắt đầu bằng biểu tượng cao nhất trong cây phân tích của câu lệnh bạn muốn ngắt. Nó làm nổi bật toán tử quan trọng nhất trong biểu thức. Đó là cùng một lý do tại sao bạn đặt một dòng khác ở đầu một dòng và không ở cuối dòng trước đó.

Trong ví dụ sau, quét lề trái, bạn thấy cấu trúc của câu lệnh dưới dạng OR của 3 biểu thức.

if (ch>='A' && ch<='Z'
    || ch>='a' && ch<='z'
    || ch>='0' && ch<='9')
{...}

Dưới đây, | | toán tử ít được làm nổi bật. Rõ ràng nó là một | | của biểu thức. Đặc biệt là nếu các dòng có độ dài khác nhau.

if (ch>='A' && ch<='Z' ||
    ch>='a' && ch<='z' ||
    ch>='0' && ch<='9')
{...}

Và chỉ để tham khảo, điều này là rất sai. | | toán tử không được tô sáng ở tất cả.

if ( ch>='A' && ch<='Z' || ch>='a'
     && ch<='z' || ch>='0' && ch<='9')
{...}

Tôi thậm chí thích đặt dấu phẩy ở đầu dòng, mặc dù tôi hiếm khi thấy điều đó. Tôi không làm điều đó trên mã chia sẻ.

var note:Object =
    { key: key
    , type: 'P'
    , text: someLongProcedureCallGettingTheUserInitials()
       + ": " + getTheTextThatWasTyped()
    };

Đối với các phương trình số học dài, tôi thường làm một trong hai điều.

để lại mọi thứ trên một dòng duy nhất:

foo = bar + baz - fizz + buzz + alpha - beta;

Tôi thường làm điều này cho các phương trình chỉ chứa phép cộng và phép trừ, tôi thấy rất dễ dàng để tạo một lỗi đánh máy với phép nhân và phép chia có thể làm rối loạn nghiêm trọng phạm vi của toán tử.

định dạng thứ hai tôi sử dụng là toán tử lũy tiến:

foo = bar;
foo += baz;
foo -= fizz;
foo += buzz;
foo /= alpha - beta;
foo *= spiff;

Tôi thấy không có lý do gì để rút ngắn nó thành một dòng duy nhất, trừ khi nó có thể được chứng minh để cải thiện hiệu suất một cách đáng chú ý. Ngoài ra, không có sự mơ hồ về những gì đang diễn ra ở đâu, và ít có cơ hội để đặt sai dấu ngoặc đơn cho các nhà khai thác /và *nhà khai thác.

Đặt ký tự nối (hoặc bất kỳ toán tử nào) ở đầu dòng giúp cải thiện khả năng đọc. Chúng tôi quét mã bằng cách tập trung vào đầu mỗi dòng. Khi một dòng bắt đầu với một toán tử, người đọc có thể nói rằng dòng đó là sự tiếp nối của câu lệnh trước bằng cách quét một ký tự đó.

Các biểu thức toán học dài luôn được sắp chữ để mỗi dòng mới bắt đầu bằng một toán tử. Không có lý do gì mà mã không nên tuân theo quy ước này.

Để biểu thức trên một dòng và nếu nó trở nên quá dài, thì hãy chia nó thành các biểu thức nhỏ hơn:

days = ((year * months_per_year) + month) * days_per_month + day

trở thành:

months = year * months_per_year + month
days = months * days_per_month + day

Nếu điều này là không thể, thì tôi thấy nó dễ đọc hơn trước khi toán tử và toán tử bắt đầu ngay bên dưới nhiệm vụ trước đó (đặt nó bên dưới biến khiến tôi phải suy nghĩ và nhận lại, điều đó gây khó chịu vì mục tiêu là để làm cho mọi thứ dễ đọc hơn):

random = years * months_per_year 
         + month * days_per_month 
         + day * hours_per_day 
         + hour * minutes_per_hour 
         + minute * seconds_per_minute 
         + second