Bu gün ve yaşta bir kod dosyasında en fazla 80 karakter genişliğinde geçerli bir neden var mı? [kapalı]

Ciddi anlamda. 22 "monitörde ekranın sadece dörtte birini kapsıyor. Bu kuralı baltalamak için biraz cephaneye ihtiyacım var.

Ben bir sınır olmaması gerektiğini söylemiyorum; Sadece diyorum ki, 80 karakter çok küçük.

Kod 80 (veya 79) sütun tutmak uygulama aslında 80 sütun aptal terminalleri veya 80 sütun çıktılarında kod düzenleme insanları desteklemek için oluşturuldu. Bu gereksinimler çoğunlukla ortadan kalktı, ancak 80 sütun kuralını korumak için hala geçerli nedenler var:

• Kodu e-postaya, web sayfalarına ve kitaplara kopyalarken kaydırmayı önlemek için.
• Birden çok kaynak pencereyi yan yana veya yan yana fark görüntüleyici kullanarak görüntülemek için.
• Okunabilirliği artırmak. Dar kod, gözlerinizi yan yana taramak zorunda kalmadan hızlı bir şekilde okunabilir.

Bence son nokta en önemli şey. Ekranlar son birkaç yılda boyut ve çözünürlükte büyümüş olsa da, gözler büyümüş değil .

80 sütunlu metin biçimlendirmesinin kökeni 80 sütunlu terminallerden daha eskidir - IBM delikli kart 1928'e dayanır ! Bu, ABD demiryolu ölçüsünün Roma İngiltere'sindeki araba tekerleklerinin genişliği ile belirlendiği (apocryphal) hikayesini anımsatıyor .

Bazen biraz daraltıcı buluyorum, ancak bazı standart sınırlara sahip olmak mantıklı , bu yüzden 80 sütun.

İşte aynı konu Slashdot tarafından kapsanıyor .

Ve işte eski bir Fortran Bildirisi:

80 karakter bugünlerde saçma bir sınır. Kod satırlarınızı, herhangi bir rastgele karakter sınırlamasına göre değil, anlamlı olduğu yere bölün.

Sadece 22 inç geniş ekran monitörü olmayan herkes uğruna yapmalısınız. Şahsen, 17 inç 4: 3 monitörde çalışıyorum ve bunu yeterince geniş buluyorum. Ancak, bu monitörlerden 3 tane var, bu yüzden hala kullanılabilir ekran alanım var.

Sadece bu değil, aynı zamanda satırlar çok uzunsa insan gözünün metin okuma problemleri vardır. Hangi çizgide olduğunuzu kaybolmak çok kolay. Gazeteler 17 inç çapındadır (veya bunun gibi bir şeydir), ancak sayfa boyunca tam olarak yazdıklarını görmezsiniz, aynı dergiler ve diğer basılı öğeler için de geçerlidir. Sütunları dar tutarsanız okumak daha kolaydır.

Küçük varyasyonlarla yinelenen bir dizi ifadeye sahip olduğunuzda, farklılıklar dikey olarak hizalanacak şekilde satırlar halinde gruplandırıldıklarında benzerlikleri ve farklılıkları görmek daha kolay olabilir.

Aşağıdakilerin birden fazla satıra bölündüğümden çok daha okunabilir olduğunu iddia ediyorum:

switch(Type) {
case External_BL:   mpstrd["X"] = ptDig1.x - RadialClrX;    mpstrd["Y"] = ptDig1.y - RadialClrY;    break;
case External_BR:   mpstrd["X"] = ptDig1.x + RadialClrX;    mpstrd["Y"] = ptDig1.y - RadialClrY;    break;
case External_TR:   mpstrd["X"] = ptDig1.x + RadialClrX;    mpstrd["Y"] = ptDig1.y + RadialClrY;    break;
case External_TL:   mpstrd["X"] = ptDig1.x - RadialClrX;    mpstrd["Y"] = ptDig1.y + RadialClrY;    break;
case Internal_BL:   mpstrd["X"] = ptDig1.x + RadialClrX;    mpstrd["Y"] = ptDig1.y + RadialClrY;    break;
case Internal_BR:   mpstrd["X"] = ptDig1.x - RadialClrX;    mpstrd["Y"] = ptDig1.y + RadialClrY;    break;
case Internal_TR:   mpstrd["X"] = ptDig1.x - RadialClrX;    mpstrd["Y"] = ptDig1.y - RadialClrY;    break;
case Internal_TL:   mpstrd["X"] = ptDig1.x + RadialClrX;    mpstrd["Y"] = ptDig1.y - RadialClrY;    break;
}

Güncelleme: Yorumlarda , bunun yukarıdakileri yapmanın daha özlü bir yolu olacağı önerildi:

switch(Type) {
  case External_BL: dxDir = - 1; dyDir = - 1; break;
  case External_BR: dxDir = + 1; dyDir = - 1; break;
  case External_TR: dxDir = + 1; dyDir = + 1; break;
  case External_TL: dxDir = - 1; dyDir = + 1; break;
  case Internal_BL: dxDir = + 1; dyDir = + 1; break;
  case Internal_BR: dxDir = - 1; dyDir = + 1; break;
  case Internal_TR: dxDir = - 1; dyDir = - 1; break;
  case Internal_TL: dxDir = + 1; dyDir = - 1; break;
}
mpstrd["X"] = pt1.x + dxDir * RadialClrX;
mpstrd["Y"] = pt1.y + dyDir * RadialClrY; 

Şimdi 80 sütuna sığmasına rağmen, benim açımdan hala ayakta olduğunu düşünüyorum ve sadece kötü bir örnek seçtim. Yine de bir satıra birden fazla ifade yerleştirmenin okunabilirliği artırabildiğini göstermektedir.

Tek aralıklı yazı tipini varsayılan boyutlarda yazdırmak (A4 kağıda) 80 sütun 66 satırdır.

Ben daha büyük ekranlar avantajı birbirinin yanında birden fazla kod parçası için kullanın.

Benden cephane alamayacaksın. Aslında, acil durumlarda kodu bir metin konsolundan değiştirmem gereken nadir durumlar gördüğüm için değiştiğini görmekten nefret ediyorum.

Süper uzun satırları okumak daha zordur. Monitörünüzde 300 karakter alabilmeniz satırları bu kadar uzun yapmanız gerektiği anlamına gelmez. Başka bir seçeneğiniz yoksa (bir dizi parametreye ihtiyaç duyan bir çağrı) 300 karakter bir ifade için çok karmaşıktır.

Genel bir kural olarak 80 karakter kullanıyorum, ancak zorlama istenmeyen bir yere satır sonu koymak anlamına gelir.

80 karakter içinde kalmak için zorlamak tek şey benim yorum olduğunu.

Şahsen ... tüm beyin gücümü (az olanı) doğru kodlamaya adadım, bir sonraki işleve zaman harcayabildiğimde geri dönüp her şeyi 80 karakter sınırında kırmak zorunda kalıyorum . Evet, Resharper bunu benim için yapabilirdi ama sanırım 3. parti bir ürün kod düzenim hakkında kararlar alıyor ve değiştiriyor ("Lütfen kodumu iki satıra ayırmayın HAL. HAL?" ).

Bununla birlikte, oldukça küçük bir ekip üzerinde çalışıyorum ve tüm monitörlerimiz oldukça büyük, diğer programcılarımı rahatsız eden şeylerden endişe etmek, bu kadar büyük bir endişe değil.

Bazı diller paranın daha fazla patlama uğruna daha uzun kod satırlarını teşvik ediyor gibi görünüyor (o zaman ifadeler kısa el).

İki adet 20 "1600x1200 monitörüm var ve 80 sütuna yapışıyorum çünkü yan yana birden fazla metin düzenleyici penceresi görüntüleyebilmeme izin veriyor. '6x13' yazı tipini (geleneksel. Xterm yazı tipi) kullanarak 80 sütun 480 piksel artı kaydırma çubuğunu kaplıyor Bu, 1600x1200 monitörde bu türden üç pencereye sahip olmasını sağlar.Pencerelerde Lucida Konsolu yazı tipi bunu tam olarak yapmaz (minimum kullanılabilir boyut 7 piksel genişliğindedir), ancak 1280x1024 monitör iki sütun görüntüler ve HP LP2465 gibi bir 1920x1200 monitör 3 görüntüleyecektir. Ayrıca, çeşitli explorer, özellikler ve Visual Studio'daki diğer pencereler için yan tarafta biraz yer bırakacaktır.

Ayrıca çok uzun metin satırlarını okumak zordur. Metin için en uygun 66 karakterdir. Aşırı uzun tanımlayıcıların verimsiz olmaya başladığı bir nokta vardır, çünkü kodları tutarlı bir şekilde yerleştirmeyi zorlaştırırlar. İyi düzen ve girinti, kod yapısı ile ilgili görsel ipuçları sağlar ve bazı diller (Python akla gelir) bunun için girintiyi açıkça kullanır.

Bununla birlikte, Java ve .Net için standart sınıf kitaplıkların çok uzun tanımlayıcılardan daha fazla olma eğilimi vardır, bu yüzden bunu yapabilmek için mutlaka garanti verilemez. Bu durumda, kodu satır kesmeleriyle yerleştirmek, yapıyı açıklaştırmaya yardımcı olur.

Burada '6x13' yazı tiplerinin Windows sürümlerini alabileceğinizi unutmayın .

İnsanlar uzun kod satırlarının karmaşık olduğunu söylüyorlar. Basit bir Java sınıfı düşünün:

public class PlaintiffServiceImpl extends RemoteServiceServlet implements PlaintiffService {

Bu 94 karakter uzunluğunda ve sınıf adı oldukça kısadır (GWT standartlarına göre). 2 satırda okumak zor olurdu ve bir satırda çok okunabilir. Bu konuda pragmatik olmak ve böylece "geriye dönük uyumluluk" sağlamak, 100 karakter doğru genişlik olduğunu söyleyebilirim.

Diğer cevaplar zaten işleri güzelce özetledi, ancak bazı kodları ne zaman bir e-postaya kopyalayıp yapıştırmak isteyeceğinizi veya bir fark yoksa kodlamayı düşünmek de önemlidir.

Bu, "maksimum genişliğe" sahip olmanın yararlı olduğu bir zamandır.

Kodunuzu koruyacak tek kişi siz değilsiniz.

Bir sonraki 17 inç ekrana sahip olabilir veya metni okumak için büyük yazı tiplerine ihtiyaç duyabilir. Sınır, bir yerde olmalı ve önceki ekran sınırlamaları nedeniyle 80 karakter olmalıdır. Herhangi bir yeni standart (120) ve neden "Xpt yazı tipindeki monitörüme uyan budur?"

Unutmayın, her kural için her zaman istisnalar vardır, bu yüzden 80'den fazla karakter olması mantıklı olan belirli bir satır veya kod bloğuna sahipsiniz.

Ama önce "bu kod 80 karakter içinde yaşayamayacağı kadar kötü mü?"

Linux kodlama standardında, sadece 80 karakter sınırını korumakla kalmaz, aynı zamanda 8 boşluk girintisi kullanırlar.

Akıl yürütmenin bir parçası, doğru kenar boşluğuna ulaşırsanız, bir girinti seviyesini ayrı bir işleve taşımayı düşünmenizdir.

Girinti uzunluklarına bakılmaksızın, birçok iç içe kontrol yapısına sahip kodu okumak daha zor olduğu için bu daha net bir kod sağlayacaktır.

Kodumu Macbook'umdaki ekranımın yarısından daha azına rahatça uyan 100 karaktere genişlettim. 120 karakter muhtemelen satırların çok uzun ve karmaşık olmaya başlamasından önceki sınırdır. Çok geniş olmak istemezsiniz, bileşik ifadeleri ve derin iç içe kontrol yapılarını teşvik edersiniz.

Doğru marj, doğanın ekstra bir yöntem yeniden düzenleme gerçekleştirmenizi söylemenin yoludur .

Bunun bu gün ve yaşta daha fazla soruna neden olup olmayacağını merak ediyorum. C (ve muhtemelen diğer dillerde) işlev adının ne kadar uzun olabileceğine ilişkin kurallar olduğunu unutmayın. Bu nedenle, genellikle C kodunda anlaşılması çok zor isimler görürsünüz. İyi olan şey, çok fazla alan kullanmamaları. Ancak C # veya Java gibi bir dilde koda her baktığımda, yöntem adları genellikle çok uzundur, bu da kodunuzu 80 karakter uzunluğunda tutmayı imkansız hale getirir. Kodu yazdırmanız gerekmediği sürece bugün 80 karakterin geçerli olduğunu sanmıyorum.

İşverenim için kodlama ilkelerinin yazarı olarak satır uzunluğunu 80'den 132'ye çıkardım. Neden bu değer? Diğerlerinin de belirttiği gibi, 80, birçok eski donanım terminalinin uzunluğudur. Ve 132 de öyle! Terminaller geniş moddayken hat genişliği . Herhangi bir yazıcı, yoğun yazı tipi ile geniş modda basılı kopyalar yapabilir.

80'de kalmamanın nedeni,

• tanımlayıcılar için anlamı olan daha uzun adları tercih edin
• C yapıları ve numaralandırmalar için typedefs rahatsız etmeyin (onlar KÖTÜ, yararlı bilgiler gizlemek! Eğer inanmıyorsanız Peter van der Linden "Derin C Sırları" sormak), bu yüzden struct FOO func(struct BAR *aWhatever, ...)kod typedef fanatik kodu daha var .

ve bu kurallara göre sadece 80 karakter / çizgi çirkin çizgi sargılarının gözlerimin kabul edilebilir olduğundan daha sık olmasına neden olur (çoğunlukla prototiplerde ve fonksiyon tanımlarında).

Diğerlerinin söylediği gibi, (1) yazdırma ve (2) birden çok dosyayı dikey olarak yan yana görüntülemek için en iyisi olduğunu düşünüyorum.

Genişliğimi 100 karakterle sınırlamayı seviyorum, geniş ekran monitörde iki SxS düzenleyicisine izin vermek istiyorum. Artık tam olarak 80 karakterlik bir sınır için iyi bir neden olduğunu düşünmüyorum.

Orantılı yazı tipleri kullanın.

Ciddiyim. Genellikle bir satırda okunabilirlik veya yazdırılabilirlikten ödün vermeden 100-120 karakterlik bir denklik elde edebilirim. Aslında iyi bir yazı tipi (örn. Verdana) ve sözdizimi renklendirmesi ile okumak daha da kolaydır. Birkaç gün boyunca biraz garip görünüyor, ama çabucak alışıyorsunuz.

Basit bir nedenden ötürü 80 karaktere yakın şeyleri tutmaya çalışıyorum: bundan çok daha fazlası, kodumun çok karmaşık hale geldiği anlamına geliyor. Aşırı ayrıntılı özellik / yöntem adları, sınıf adları, vb.

Ben öncelikle bir Python kodlayıcıyım, bu yüzden bu iki sınırlama kümesi üretir:

1. Uzun kod satırları yazma
2. Çok fazla girintileme

İki veya üç girinti seviyesine ulaşmaya başladığınızda, mantığınız kafa karıştırır. Aynı sayfada tek bir bloğu tutamıyorsanız, kodunuz hatırlanması çok karmaşık ve zor hale geliyor. 80 karakter içinde tek bir satır tutamıyorsanız, satırınız aşırı derecede karmaşıklaşıyor.

Python'da okunabilirlik pahasına nispeten özlü kod yazmak (bkz. Codegolf) kolaydır, ancak okunabilirlik pahasına ayrıntılı kod yazmak daha da kolaydır. Yardımcı yöntemler kötü bir şey değildir ve yardımcı sınıflar da değildir. Aşırı soyutlama bir sorun olabilir, ancak bu başka bir programlama zorluğudur.

C gibi bir dilde şüphe duyduğunuzda, başka bir işleve çağrı yapma ve geri atlama yükünü istemiyorsanız, yardımcı işlevleri yazın ve bunları satır içine alın. Çoğu durumda, derleyici işleri sizin için akıllıca halledecektir.

Buna zaten çok iyi cevaplar var, ancak IDE'nizde solda bir dosya listesinin ve sağda (veya başka herhangi bir yapılandırmada) bir işlev listesinin olabileceğini belirtmek gerekir.

Kodunuz çevrenin sadece bir parçasıdır.

Ben 80 karakter zorlamak değil bir şey sonunda kelime kaydırma anlamına gelir.
IMO, bir maksimum genişlik çizgisi için seçilen herhangi bir uzunluk her zaman uygun değildir ve kelime kaydırma olası bir cevap olmalıdır.
Ve bu göründüğü kadar kolay değil.

Kelime kaydırma sunan jedit _{(kaynak: jedit.org )} içinde uygulanır.

Ama bir tuvalet zaman içinde tutulma acı acı özledim ! (aslında 2003'ten beri), çünkü metin editörü için bir kelime kaydırma şunları içerir:

• Sarılmış satır bilgileri metin görüntüleyici, kod gezinme, dikey cetveller içindir.
• Goto satırı, satır numaralandırma cetveli sütunu, geçerli satır vurgulama, dosya kaydetme gibi işlevler için kaydırılmamış satır bilgisi gerekir.

Aslında kendi kodum için de benzer bir kural uyguluyorum ama sadece A4 sayfasına kod bastığım için - 80 sütun istenen yazı tipi boyutum için doğru genişlikle ilgili.

Ama bu kişisel tercih ve muhtemelen peşinde olduğunuz şey değil (çünkü cephanenin başka yöne gitmesini istiyorsunuz).

Limitin ardındaki mantığı sorgulamayan şey - cidden, eğer kimse neden böyle bir neden ortaya alamazsa, kodlama standartlarınızdan çıkarılması için iyi bir vakanız var.

Gün boyu yan yana ayrılıyorum ve 22 inçlik garip bir monitörüm yok. Hiç yapar mıyım bilmiyorum. Bu, elbette, ok kodlama ve 300 karakterlik çizgileri kullanan sadece yazma programcılarının ilgisini çekmiyor.

Evet, çünkü bu gün ve yaşta bile, bazılarımız ekranın sadece 80 karakter görüntüleyebileceği terminalleri (tamam, çoğunlukla terminal emülatörleri) kodluyoruz. Yani, en azından yaptığım kodlama için, 80 karakter kuralını gerçekten takdir ediyorum.

Hala sınırın görsel kısımda sınırlı olmadığını düşünüyorum. Elbette, monitörler ve çözünürlükler günümüzde bir satırda daha fazla karakter gösterecek kadar büyük, ancak okunabilirliği artırıyor mu?

Limit gerçekten de iyi bir sebebi var dikte edildiği takdirde kodunu yeniden düşünmek ve değil bir satır içine her şeyi koymak için. Girintiyle aynıdır - çok fazla seviyeye ihtiyacınız varsa kodunuzun yeniden düşünülmesi gerekir.

80 karakter kırmak, kodlama sırasında yaptığınız bir şeydir , daha sonra değil. Elbette yorumlarla aynı. Çoğu editör, 80 karakter sınırının nerede olduğunu görmenize yardımcı olabilir.

(Bu biraz OT olabilir, ancak Eclipse'de, kodu kaydettiğinizde biçimlendiren bir seçenek vardır (istediğiniz kurallara göre) Bu ilk başta biraz garip, ancak bir süre sonra biçimlendirme, oluşturulan koddan daha fazla elinizde değildir.)

Biz birini olsaydı bunlar , bu tartışmayı yapmak olmaz! ;-)

Ancak ciddiyetle insanların cevaplarında gündeme getirdikleri konular oldukça meşrudur. Ancak orijinal poster bir sınıra karşı değildi, sadece 80 sütun çok azdı.

Kod pasajlarının e-posta ile gönderilmesi meselesinin bir değeri vardır. Ancak çoğu e-posta istemcisinin önceden biçimlendirilmiş metne yaptığı kötü şeyleri göz önünde bulundurarak satır kaydırmanın sorunlarınızdan sadece biri olduğunu düşünüyorum.

Yazdırmaya gelince, genellikle 100 karakter çizgisinin yazdırılan bir sayfaya çok rahat bir şekilde uyduğunu görüyorum .

Çizgilerimi 80 sütunun altında tutmaya çalışıyorum. En güçlü nedeni, sık sık kendimi kullanarak grepve lesskomut satırında çalışırken kodumu taramak bulmak . Terminallerin uzun kaynak hatlarını nasıl kırdığını gerçekten sevmiyorum (sonuçta bu iş için yapılmadı). Başka bir neden, her şeyin satıra sığması ve editör tarafından kırılmaması durumunda daha iyi görünüyor. Örneğin, uzun fonksiyon çağrılarının parametrelerini birbirine ve benzer şeylerin altına güzelce hizalamak.