Pemutusan saluran sebelum / sesudah operator [ditutup]

Sementara konvensi kode Java Sun menyarankan untuk menempatkan line break di hadapan operator, banyak pedoman lain tidak setuju dengannya. Saya tidak melihat pro dan kontra yang jelas, jadi apakah ada keuntungan menggunakan salah satu gaya ini di atas yang lain?

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

vs.

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

Saya akan meninggalkannya di satu baris dan lebih suka berpikir tentang keterbacaan dalam hal nama variabel yang mengungkapkan niat (dan fungsi).

Setelah menjadi berantakan saatnya untuk refactor :

• ganti nama vars
• memperkenalkan vars / fungsi baru

Contoh

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

vs.

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

Saya bisa membayangkan keterbacaan menjadi argumen

result = longidentifier +
   short -
   alittlelonger -
   c;

melawan

result = longidentifier
   + short
   - alittlelonger
   - c;

Dalam contoh kedua, operator berbaris dengan baik dan Anda dapat dengan mudah melihat dengan tanda mana variabel dimasukkan ke dalam persamaan. Saya pikir ini juga masuk akal untuk operator biner, tetapi dengan menguatkan dll, Anda harus melakukan apa pun yang lebih jelas.

Saya biasanya mengikuti pedoman gaya yang paling umum digunakan atau alat standar pengkodean tertentu. Keuntungan menggunakan gaya yang umum digunakan membawa manfaat ketika Anda membaca kode orang lain atau terlibat dalam proyek sumber terbuka di mana pedoman gaya ditetapkan.

Gaya paling umum yang saya lihat adalah gaya kedua dalam pertanyaan. Lihat di bawah untuk daftar mereka:

Panduan Gaya Google :

Ketika garis terputus di operator yang tidak ditugaskan, jeda datang sebelum simbol.

Konvensi Sun Coding :

Beristirahat di depan operator

Checkstyle Operator Wrap cek 's nilai default adalah nl:

Operator harus berada di jalur baru

Dalam kode saya cenderung memberi istirahat setelah operator:

foo = some_long_expression() +
      some_other_long_expression();

Di sini, operator yang menggantung di ujung garis merupakan petunjuk besar bagi pembaca bahwa kode terus berlanjut. Dalam bahasa yang tidak memiliki terminator pernyataan, bahwa operator menggantung dapat berfungsi sebagai petunjuk yang cukup untuk kompiler / juru bahasa bahwa kode terus berlanjut (jika tidak saya harus menggunakan beberapa konstruksi garis kelanjutan yang jelek).

Ketika mendokumentasikan ungkapan itu (jika perlu dokumentasi), saya cenderung meletakkan istirahat di depan operator.

Selama Anda tetap konsisten, maka ketahuilah bahwa tidak ada keuntungan nyata. Ini sangat penting ketika mempertimbangkan penggabungan kode dan ruang putih.

Saya percaya garis harus dimulai dengan simbol tertinggi di pohon parse dari pernyataan yang ingin Anda hancurkan. Ini menyoroti operator yang paling penting dalam ekspresi. Ini adalah alasan yang sama mengapa Anda meletakkan yang lain di awal baris dan bukan di akhir baris sebelumnya.

Pada contoh berikut, memindai margin kiri, Anda melihat struktur pernyataan sebagai OR dari 3 ekspresi.

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

Di bawah, || operator kurang disorot. Itu kurang jelas itu adalah || ekspresi. Apalagi jika garis-garis itu panjangnya berbeda.

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

Dan hanya untuk referensi, ini sangat salah. The || operator tidak disorot sama sekali.

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

Saya bahkan suka meletakkan koma di awal baris, meskipun saya jarang melihatnya. Saya menahan diri dari melakukan hal itu pada kode bersama.

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

Untuk persamaan aritmatika yang panjang, saya biasanya melakukan satu dari dua hal.

tinggalkan semuanya dalam satu baris:

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

Saya biasanya melakukan ini untuk persamaan yang hanya berisi penambahan dan pengurangan, saya merasa sangat mudah untuk membuat kesalahan ketik dengan perkalian dan pembagian yang secara serius dapat mengacaukan ruang lingkup operator.

format kedua yang saya gunakan adalah operator progresif:

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

Saya tidak melihat alasan untuk mempersingkat menjadi satu baris, kecuali jika itu dapat dibuktikan untuk meningkatkan kinerja secara nyata. Selain itu, tidak ada ambiguitas tentang apa yang terjadi di mana, dan ada sedikit kesempatan untuk salah menempatkan tanda kurung untuk /dan *operator.

Menempatkan karakter gabungan (atau operator apa pun) di awal saluran akan meningkatkan keterbacaan. Kami memindai kode dengan berfokus pada awal setiap baris. Ketika sebuah garis dimulai dengan sebuah operator, pembaca dapat mengatakan bahwa garis tersebut merupakan kelanjutan dari pernyataan sebelumnya dengan memindai satu karakter itu.

Ekspresi matematika yang panjang selalu mengeset sehingga setiap baris baru dimulai dengan operator. Tidak ada alasan bahwa kode tidak boleh mengikuti konvensi ini.

Biarkan ekspresi pada satu baris, dan jika itu menjadi terlalu panjang, maka pisahkan menjadi ekspresi yang lebih kecil:

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

menjadi:

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

Jika ini tidak mungkin, maka saya merasa lebih mudah untuk istirahat sebelum operator, dan memiliki operator mulai langsung di bawah tugas sebelumnya (meletakkannya di bawah variabel membuat saya harus berpikir dan memulai kembali, yang menjengkelkan mengingat bahwa tujuannya adalah adalah untuk mempermudah membaca):

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