Cách dễ đọc nhất để định dạng dài nếu điều kiện? [đóng cửa]

ifĐiều kiện quanh co dài nên tránh nếu có thể, nhưng đôi khi tất cả chúng ta cuối cùng đã viết chúng. Ngay cả khi đó là một điều kiện rất đơn giản, các tuyên bố liên quan đôi khi chỉ đơn giản là rất dài dòng, vì vậy toàn bộ điều kiện kết thúc rất dài. Cách dễ nhất để định dạng những gì?

if (FoobarBaz::quxQuux(corge, grault) || !garply(waldo) || fred(plugh) !== xyzzy) {
    thud();
}

hoặc là

if (
    FoobarBaz::quxQuux(corge, grault)
 || !garply(waldo)
 || fred(plugh) !== xyzzy
) {
    thud();
}

hoặc là

if (FoobarBaz::quxQuux(corge, grault)
    || !garply(waldo)
    || fred(plugh) !== xyzzy) {
    thud();
}

hoặc là

thudable = FoobarBaz::quxQuux(corge, grault);
thudable ||= !garply(waldo);
thudable ||= fred(plugh) !== xyzzy;

if (thudable) {
    thud();
}

hoặc bất kỳ ưu tiên khác?

Thông thường, một điều kiện dài nếu là dấu hiệu của mã cần tái cấu trúc, nhưng đôi khi bạn không thể tránh được. Trong những trường hợp đó, tôi thích cái đầu tiên:

if (bar || baz || quux) { ... }

Bởi vì bạn có thể nói những gì đang diễn ra với một dòng. Tuy nhiên, tôi muốn làm một cái gì đó như thế này, khi có thể:

function foo() {
  return bar || baz || quux;
}

if (foo()) { ... }

Tôi thích giữ các toán tử ở cuối để chỉ ra sự tiếp tục:

if (the_function_being_called() != RETURNCODE_SUCCESS &&
    the_possibly_useful_recovery_strategy() == RETURNCODE_EPICFAIL &&
    this_user_has_elected_to_recieve_error_reports)
{
    report_error();
}

Tôi là một fan hâm mộ lớn của các tên biến có ý nghĩa:

const bool isInAStrangeCondition =
    FoobarBaz::quxQuux(corge, grault) ||
    !garply(waldo) ||
    fred(plugh) !== xyzzy;

if (isInAStrangeCondition) {
    thud();
}

Hoặc tái cấu trúc như một chức năng, như đã đề cập ở trên.

Tôi phá vỡ các biểu thức con lộn xộn hơn, hoặc tất cả chúng, dưới dạng các biến bool. Sau đó, logic boolean cấp cao nhất của câu lệnh 'if' có thể được làm rõ. Trong các loại công việc tôi làm, không phải lúc nào cũng có vài thứ ORed hoặc ANDed.

bool goodblah = some_mess < whatever;
bool frobnacious = messy_crud != junky_expression;
bool yetanother = long_winded_condition;

if (goodblah || (frobnacious && yetanother))   {
    ...
}

Điều này đặc biệt tốt trong trình gỡ lỗi, nơi tôi có thể xem tất cả các bool trước khi thực hiện 'nếu'.

Tôi có xu hướng căn chỉnh các toán tử khi bắt đầu các dòng mới để tôi nhớ cách tôi kết hợp các thuật ngữ (cả logic dài và số học dài). Như thế này:

if (first_attempt(data) == SUCCESS
    || (reusable(data) && second_attempt(data) == SUCCESS)
    || (still_reusable(data) && third_attempt(data) == SUCCESS))
  return SUCCESS;

Điều này chỉ hoạt động nếu tôi thụt lề bởi 2 khoảng trắng hoặc đặt môi trường của tôi thành các biến vị ngữ đa dòng thụt lề nhiều hơn, nếu không, thật khó để biết vị từ kết thúc và mã hữu ích bắt đầu từ đâu.

Tôi là một fan hâm mộ của những điều sau đây:

if (really_long_expression && another_really_really_long_expression && 
            another_very_long_expression_OMG_id_it_long){
    bugs();
}

Bằng cách này, nó vẫn trông giống như một biểu thức if và không phải là một biểu thức bị phá vỡ nếu biểu thức. Việc thụt lề giúp hiển thị rằng đó là sự tiếp nối của dòng trước đó.

Bạn cũng có thể thụt lề cho đến khi dấu ngoặc mở ở cuối dòng trước để nó ở cuối biểu thức if như lẽ ra phải có.