Operatörden önceki / sonraki satır sonu [kapalı]

Sun'ın Java kodu konvansiyonu, operatörün önüne satır sonu koymayı önermektedir, diğer birçok kılavuz buna katılmamaktadır. Herhangi bir belirgin avantaj ve dezavantaj göremiyorum, bu yüzden bu tarzlardan birini diğerine kullanmanın avantajları var mı?

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

vs

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

Bunu bir satırda bırakıp, niyeti açığa çıkaran değişken isimleri (ve fonksiyonlar) açısından okunabilirliği düşünürdüm.

Ortalık dağılınca , yeniden harekete geçme zamanı :

• vars yeniden adlandır
• yeni değişkenler / fonksiyonlar tanıtmak

Örnek

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

vs.

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

Okunabilirliğin bir argüman olduğunu hayal edebiliyorum

result = longidentifier +
   short -
   alittlelonger -
   c;

e karşı

result = longidentifier
   + short
   - alittlelonger
   - c;

İkinci örnekte, operatörler güzel bir şekilde sıralanmıştır ve değişkenin denkleştirmeye hangi işareti girdiğini kolayca görebilirsiniz. Bence bu ikili operatörler için de anlam ifade ediyor, ancak destek vb. İle daha net olanı yapmalısınız.

Normalde en çok kullanılan stil kurallarını veya belirli bir kodlama standart araçlarını izlerim. Yaygın olarak kullanılan bir stil kullanmanın avantajı, başkalarının kodlarını okurken veya bir stil kurallarının belirlendiği açık kaynak kodlu bir projede yer aldığınızda fayda sağlar.

Gördüğüm en yaygın stiller, sorudaki ikinci stildir. Bunların listesi için aşağıya bakın:

Google Stil Kılavuzu :

Atama dışı bir operatörde bir çizgi kesildiğinde, mola sembolden önce gelir.

Sun Kodlama Sözleşmesi :

Bir operatörden önce ara

Checkstyle Operatör Wrap çek 'ın varsayılan değer nl geçerli:

Operatör yeni bir satırda olmalı

Kodda operatörden sonra ara verme eğilimindeyim:

foo = some_long_expression() +
      some_other_long_expression();

Burada bir satırın sonundaki sarkan operatör, kodun devam ettiği okuyucuya büyük bir ipucudur. İfade sonlandırıcıları olmayan dillerde, bu sarkan operatör, derleyiciye / tercümana kodun devam etmesi için yeterli bir ipucu olarak hizmet verebilir (aksi halde çirkin bir devam hattı yapısı kullanmak zorunda kalırdım).

Bu ifadeyi belgelendirirken (dokümantasyona ihtiyacı varsa), molayı operatörden önce koyma eğilimindeyim.

Tutarlı kaldığınız sürece, hiçbir şekilde gerçek bir avantajın olmadığını bilin. Bu özellikle kod birleştirme ve beyaz boşluk dikkate alındığında önemlidir.

Satırın, kırmak istediğiniz ifadenin ayrıştırma ağacındaki en yüksek sembolle başlaması gerektiğine inanıyorum. İfadede en önemli olan işleci vurgular. Önceki satırın sonuna değil, satırın başına başka bir satır koymanızın nedeni aynıdır.

Aşağıdaki örnekte, sol kenar boşluğunu taradığınızda, ifadenin yapısını 3 ifadenin OR'si olarak görürsünüz.

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

Aşağıda, || operatörler daha az vurgulanır. Bu bir daha az belirgindir || ifadelerin Özellikle, çizgiler farklı uzunluklarda olsaydı.

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

Ve sadece referans olarak, bu çok yanlış. || operatörler hiç vurgulanmaz.

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

Hatta nadiren görmeme rağmen, satırın başına virgül koymayı seviyorum. Bunu paylaşılan kodda yapmaktan kaçınıyorum.

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

Uzun aritmetik denklemler için genellikle iki şeyden birini yaparım.

her şeyi tek bir satırda bırakın:

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

Bunu sadece toplama ve çıkarma içeren denklemler için yapıyorum, operatörün kapsamını ciddi şekilde karıştırabilecek çarpma ve bölme ile yazım hatası yapmayı çok kolay buluyorum.

kullandığım ikinci biçim aşamalı işleçler:

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

Performansı gözle görülür şekilde iyileştirmediği kanıtlanmadıkça, onu tek bir hatta kısaltmak için hiçbir neden görmüyorum. Ek olarak, nerede olup bittiğine dair hiçbir belirsizlik yoktur ve /ve *operatörler için bir parantezi yanlış yerleştirme şansı daha azdır .

Birleştirme karakterini (veya herhangi bir işleci) satırın başına yerleştirmek okunabilirliği artırır. Her satırın başında odaklanarak kodu tarıyoruz. Bir satır bir operatörle başladığında, okuyucu, bir karakterin taranmasıyla satırın önceki ifadenin devamı olduğunu söyleyebilir.

Uzun matematiksel ifadeler her zaman dizgiseldir, böylece her yeni satır bir işleçle başlar. Kodun bu sözleşmeyi izlememesi için hiçbir sebep yoktur.

İfadeyi bir satırda bırakın ve çok uzun olursa, o zaman daha küçük ifadelere ayırın:

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

dönüşür:

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

Bu mümkün değilse, operatörden önce kırmayı daha fazla okunabilir buluyorum ve operatörün doğrudan önceki atamanın altına başlamasını sağlamak (değişkenin altına koymak beni düşündürmek zorunda bırakıyor; şeyleri okumayı kolaylaştırmak için):

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