Senyawa styling DAN / ATAU jika pernyataan

Bagaimana Anda mendesain senyawa kompleks AND / OR jika pernyataan untuk keterbacaan maksimum? Bagaimana Anda indentasi dan di mana Anda menempatkan garis terputus? Situasi khusus saya adalah seperti berikut ini. Ini jelas lebih baik daripada menghancurkan semuanya menjadi satu baris, tetapi masih terlihat berantakan.

if (
    (
        x == y
        && a != b
        && p.isGood() 
        && (
            i + u == b
            || q >= a
        )
    )
    || k.isSomething()
    || m > n
) {
    doSomething();
}

Buat variabel boolean untuk setiap langkah kecil:

bool step1 = i + u == b || q >= a;
bool step2 = a != b && p.isGood() && group1;
bool step3 = group2 || k.isSomething() || m > n;
if (step3) { doSomething(); }

Ini tentu saja mirip dengan jawaban Lacrymology, kecuali dengan nama yang berbeda untuk setiap langkah.

Jika Anda menyebutkan step1, step2dan step3dengan cara yang masuk akal secara konseptual, ini seharusnya yang paling mudah dibaca. p.isGood()dan k.isSomething()kadang-kadang dapat dipanggil dalam situasi di mana itu tidak ada dalam kode asli Anda, jadi ini tidak akan menjadi pilihan jika fungsi-fungsi itu mahal atau jika Anda menjalankan kode ini dalam loop yang sangat ketat.

Di sisi lain, Anda tidak perlu khawatir tentang hit kinerja yang membuat variabel baru mungkin terjadi; kompiler yang baik akan mengoptimalkannya.

Contoh dengan deteksi tabrakan persegi panjang (yang mungkin tidak Anda gunakan karena hit kinerja yang disebutkan di atas):

if((a.x + a.width >= b.x || b.x + b.width >= a.x)
 && (a.y + a.height >= b.y || b.y + b.width >= a.y)
)
{ collision(); }

Mungkin menjadi:

bool horizMatch = a.x + a.width >= b.x || b.x + b.width >= a.x;
bool vertMatch = a.y + a.height >= b.y || b.y + b.width >= a.y;
if(horizMatch && vertMatch) { collision(); }

Juga, jika Anda ingin meninggalkan kode Anda apa adanya, saya pikir itu akan baik-baik saja juga. Jujur saya pikir kode Anda cukup terbaca. Jelas saya tidak tahu apa sebenarnya a b x y i u p k m n, tetapi sejauh struktur berjalan, itu terlihat baik bagi saya.

Saya biasanya faktor ulang kode saya menjadi lebih modular jika kondisi saya menjadi rumit.

Saya akan melakukan sesuatu yang lebih seperti ini, pada tingkat kerumitan ini

bool doIt = x == y && a != b && p.isGood();
doIt &= ( i + u == b || q >= a);
doIt |= k.isSomething() || m > n;

if(doIt)
{
    doSomething();
}

itu jelek, tapi itu bisa dibaca dan saya cukup yakin kompiler akan tahu bagaimana cara membuatnya.

Di sisi lain, jika saya pernah melihat diri saya dalam situasi menulis pernyataan IF seperti itu, saya memikirkan kembali solusinya, karena saya TERTENTU ada cara untuk melakukannya secara lebih sederhana, atau setidaknya mengabstraksikan beberapa kondisi itu (misalnya: mungkin x == y && a != b && p.isGood()benar-benar hanya berarti this->isPolygon()dan saya dapat membuat metode itu;

Saya menjadi kurang terobsesi dengan perataan vertikal dari waktu ke waktu, tetapi bentuk umum saya dengan ekspresi multisaluran ...

if (   (   (expr1 == expr2)
        || (expr3 == expr4)
        || (expr5 == expr6)
       )
    && (   (expr7 == expr8)
        || (expr9 == expra)
       )
   )
{
  blah;
}

Poin-poin penting ...

• Paren tutup sejajar secara vertikal dengan paren terbuka, seperti dengan kawat gigi.
• Sub-ekspresi yang sesuai dalam satu baris berada dalam satu baris, dan disejajarkan secara vertikal di sebelah kiri. Di mana itu membantu keterbacaan, operator infiks dalam bagian-bagian single-line juga selaras secara vertikal.
• Kawat gigi penutup secara alami membuat garis yang hampir kosong, membantu mengelompokkan berbagai hal secara visual.

Terkadang, saya akan memformat +dan *atau beberapa operator lain juga seperti ini. Cukup banyak ekspresi kompleks yang mengambil bentuk penjumlahan-produk-atau-jumlah-produk (yang dapat merujuk pada "jumlah" dan "produk" boolean) sehingga mungkin cukup umum bahwa gaya yang konsisten untuk itu bermanfaat.

Berhati-hatilah dengan ini. Sering kali lebih baik untuk refactor (memindahkan bagian dari ekspresi ke dalam suatu fungsi, atau menghitung dan menyimpan bagian perantara dalam suatu variabel) daripada menggunakan lekukan untuk mencoba membuat ekspresi overcomplex lebih mudah dibaca.

Jika Anda lebih suka menumpuk parens dekat Anda di sisi kanan, saya tidak membencinya , tapi saya kira itu tidak terlalu buruk. Terlalu jauh, Anda mengambil risiko bahwa kesalahan dapat membuat lekukan salah menggambarkan apa yang dilakukan oleh kurung.

if (   (   (expr1 == expr2)
        || (expr3 == expr4)
        || (expr5 == expr6))

    && (   (expr7 == expr8)
        || (expr9 == expra)))
{
  blah;
}

http://www.codinghorror.com/blog/2006/01/flattening-arrow-code.html

Saya setuju dengan jawaban JohnFx dan juga oleh Lacrymology. Saya akan membangun banyak fungsi (lebih disukai statis) yang mencapai tujuan kecil dan kemudian membangunnya dengan cara yang cerdas.

Jadi, bagaimana dengan yang seperti ini? Catatan, ini bukan solusi yang sempurna, tetapi berhasil. Ada cara untuk membersihkan ini lebih lanjut, tetapi informasi yang lebih spesifik diperlukan. Catatan: kode ini harus berjalan sama cepatnya, karena kompilernya pintar.

// Currently based on members or global vars
// (which is often a bad idea too)
function doSomethingCondirionally()
{
  if (k.isSomething() || m > n)
  {
    doSomething();
    return;
  }

  // Else ... 
  if (x != y) return;
  if (a == b) return;
  if (!p.isGood()) return;

  // Final, positive check
  if (i + u == b || q >= a)
  {
    doSomething();
  }
}

Untuk apa nilainya, saya terkejut melihat bahwa contoh Anda sangat mirip dengan predikat rumit yang saya tulis. Saya setuju dengan orang lain bahwa predikat yang rumit bukanlah yang terbaik untuk pemeliharaan atau keterbacaan, tetapi kadang-kadang muncul.

Biarkan saya menekankan bahwa Anda melakukan bagian ini dengan benar: && a != b JANGAN PERNAH meletakkan konektor logis di akhir baris, terlalu mudah untuk dilewatkan secara visual. Tempat lain di mana Anda TIDAK PERNAH menempatkan operator di akhir baris adalah dalam rangkaian string, dalam bahasa dengan operator seperti itu.

Melakukan hal ini:

String a = b
   + "something"
   + c
   ;

Jangan lakukan ini:

String a = b +
   "something" +
   c;

Jika kondisasinya rumit, biasanya indikasi bahwa itu harus dipecah menjadi beberapa bagian. Mungkin satu klausa dapat ditugaskan ke variabel perantara. Mungkin satu klausa dapat diubah menjadi metode pembantu. Saya biasanya memilih untuk tidak memiliki banyak ands dan ors dalam satu baris.

Anda dapat memecah kode menjadi beberapa pernyataan, sehingga mudah dimengerti. Tapi ninja sungguhan akan melakukan hal seperti ini. :-)

if
(
    (
        x == y
    &&
        a != b
    &&
        p.isGood()
    &&
        (
            i + u == b
        ||
            q >= a
        )
    )
||
    k.isSomething()
||
    m > n
)
{
    doSomething();
}