İç yapıları varsa, uzun işlevler kabul edilebilir mi?

İç içe geçmiş işlevler (Python ve D gibi) destekli dillerdeki karmaşık algoritmalarla uğraşırken, genellikle büyük işlevler yazarım (algoritma karmaşık olduğu için) ancak karmaşık kodu yapılandırmak için iç içe geçmiş işlevler kullanarak hafifletirim. İç içe geçmiş işlevler kullanılarak dahili olarak iyi yapılandırılmış olsalar bile, dev (100+ satır) işlevler hala kötü olarak mı değerlendiriliyor?

Düzenleme: Python veya D ile aşina olmayanlar için, bu dillerde iç içe geçmiş işlevler de dış işlev kapsamına erişime izin verir. D'de bu erişim dış kapsamdaki değişkenlerin mutasyonuna izin verir. Python'da sadece okumayı sağlar. D'de, iç içe geçmiş bir işlevdeki dış etki alanına erişimi açıkça bildirerek devre dışı bırakabilirsiniz static.

Her zaman kuralı unutmayın, bir işlev bir şeyi yapar ve iyi yapar! Bunu yapabilirseniz, iç içe geçmiş işlevlerden kaçının.

Okunabilirliği ve testi engeller.

Bazıları kısa işlevlerin uzun işlevlerden daha hataya eğilimli olabileceğini savunuyorlar .

Kart ve Cam (1990), tasarım karmaşıklığının gerçekten iki yönü içerdiğini belirtmektedir: her bir bileşen içindeki karmaşıklık ve bileşenler arasındaki ilişkilerin karmaşıklığı.

Şahsen, iyi yorumlanmış düz çizgi kodun takip edilmesinin daha kolay olduğunu (özellikle ilk yazan kişi sen değilken) başka yerde hiç kullanılmamış birden fazla fonksiyona bölündüğünden daha kolay olduğunu buldum. Ama bu gerçekten duruma bağlı.

Bence ana paket, bir kod bloğunu böldüğünüzde, bir başkası için bir çeşit karmaşıklık ticareti yaptığınızdır. Muhtemelen ortada bir yerlerde tatlı bir yer vardır.

İdeal olarak, tüm işlev kaydırma yapmak zorunda kalmadan görüntülenebilir olmalıdır. Bazen bu mümkün değildir. Ama parçalara ayırabilirseniz, kod okumayı çok daha kolay hale getirecektir.

Sayfa Yukarı / Aşağıya bastığımda veya kodun farklı bir bölümüne geçtiğimde önceki sayfadan yalnızca 7 +/- 2 şeyi hatırlayabildiğimi biliyorum. Ve ne yazık ki, bu kodlardan bazıları yeni kodu okurken kullanılacak.

Her zaman kısa süreli belleğimi bir bilgisayarın kayıtları gibi düşünmeyi severim (CISC, RISC değil). Tüm fonksiyonun aynı sayfada olması durumunda, programın başka bir bölümünden gerekli bilgileri almak için önbelleğe gidebilirsiniz. Tüm işlev bir sayfaya sığmazsa, her işlemden sonra her zaman herhangi bir belleği diske basmaya eşdeğer olur.

Neden normal harici işlevler yerine iç içe geçmiş işlevler kullanıyorsunuz?

Dıştaki işlevler yalnızca eski, büyük işlevinizde yalnızca bir kez kullanılmış olsa bile, tüm karışıklığı okumayı kolaylaştırır:

DoThing(int x){
    x += ;1
    int y = FirstThing(x);
    x = SecondThing(x, y);
    while(spoo > fleem){
        x = ThirdThing(x+y);
    }
}

FirstThing(int x){...}
SecondThing(int x, int y){...}
ThirdThing(int z){...}

Kitabın önümde şu anda önümde yok (alıntı yapmak), ama Kurallara göre, araştırmaya göre, fonksiyon uzunluğu için "sweetspot" 25-50 satır civarındaydı.

Uzun fonksiyonlara sahip olmanın tamam olduğu zamanlar vardır:

• Fonksiyonun siklomatik karmaşıklığı düşük olduğunda. Geliştiricileriniz, eğer aynı anda ekranda değilse, eğer bir if ifadesi ve bunun için başka bir ifadeyi içeren bir fonksiyona bakmak zorunda kaldıklarında biraz sinirlenebilirler.

Uzun işlevlere sahip olmanın uygun olmadığı zamanlar:

• Çok iç içe koşullu bir işleve sahipsin. Kod okuyucularına bir iyilik yapın, işlevi parçalayarak okunabilirliği artırın. Bir işlev, okuyucuya "Bu bir şeyi yapan bir kod bloğu" olduğunu gösterir. Ayrıca, fonksiyonun uzunluğunun çok fazla bir şey yaptığını gösterip göstermediğini ve başka bir sınıfa yönlendirilmesi gerektiğini de kendinize sorun.

Sonuç olarak, bakım yapılabilirlik listenizdeki en yüksek önceliklerden biri olmalıdır. Başka bir dev kodunuza bakamıyorsa ve kodun 5 saniyeden kısa sürede ne yaptığını "anlayamazsa", ur kodu ne yaptığını söylemeye yetecek kadar "meta veri" sağlamıyor demektir. Diğer geliştiriciler, 100'den fazla kod satırı okumak yerine, seçtiğiniz IDE'deki nesne tarayıcısına bakarak sınıfınızın ne yaptığını söyleyebilmelidir.

Küçük fonksiyonlar aşağıdaki avantajlara sahiptir:

• Taşınabilirlik: İşlevselliği hareket ettirmek çok daha kolaydır (ya sınıf içinde farklı bir sisteme yeniden düzenleme yaparken)
• Hata ayıklama: Yığınlamaya baktığınızda, 100'den ziyade 25 kod satırlı bir işleve bakıyorsanız bir hatayı tam olarak belirlemek çok daha hızlıdır.
• Okunabilirlik - İşlevin adı tüm kod bloğunun ne yaptığını gösterir. Takımınızdaki bir ekip, eğer çalışmazsa o bloğu okumak istemeyebilir. Ayrıca, çoğu modern IDE'de başka bir aygıt, işlev adlarını bir nesne tarayıcısında okuyarak sınıfınızın ne yaptığını daha iyi anlayabilir.
• Gezinme - Çoğu IDE, işlevlerin adını aramanıza izin verir. Ayrıca, çoğu modern IDE bir işlevin kaynağını başka bir pencerede görüntüleme kabiliyetine sahiptir, bu da diğer aygıtlara uzun işleve bakmalarını sağlamak yerine 2 ekranda (çoklu monitörlerde) bakma şansı verir.

Liste devam ediyor.....

Cevap buna bağlı, ancak bunu muhtemelen bir sınıfa dönüştürmelisiniz.

Çoğu iç içe işlevden hoşlanmıyorum. Lambdalar bu kategoriye girer ancak 30-40 karakterden fazla olmadıkça genellikle beni işaretlemez.

Temel sebep, içsel anlamsal özyinelemeyle yerel olarak yoğun bir işleve dönüşmesi, beynimi etrafa sarmamın zor olduğu anlamına geliyor ve bazı şeyleri kod alanını karıştırmayan bir yardımcı fonksiyona itmek daha kolay .

Bir işlevin işini yapması gerektiğini düşünüyorum. Başka Şeyler Yapmak diğer fonksiyonların yaptığı şeydir. Yani, 200 çizgi bir işleve sahipseniz, Şeyini Yapıyorsanız ve hepsi akıyorsa, bu A-OK.

Kabul edilebilir mi? Bu gerçekten sadece senin cevaplayabileceğin bir soru. İşlev ihtiyaç duyduğu şeyi yapar mı? Bakım yapılabilir mi? Takımınızın diğer üyeleri için 'kabul edilebilir' mi? Eğer öyleyse, o zaman gerçekten önemli olan budur.

Düzenleme: İç içe geçmiş işlevler hakkında bir şey görmedim. Şahsen ben onları kullanmazdım. Bunun yerine düzenli fonksiyonlar kullanırdım.

Uzun bir "düz çizgi" işlevi, her zaman belirli bir sırayla gerçekleşen uzun adım dizisini belirtmenin açık bir yolu olabilir.

Bununla birlikte, diğerlerinin de belirttiği gibi, bu form, genel akışın daha az belirgin olduğu yerel karmaşıklık uzantılarına sahip olma eğilimindedir. Bu yerel karmaşıklığı iç içe geçmiş bir işleve yerleştirmek (yani: uzun işlev içinde başka bir yerde, belki üstte ya da altta tanımlanmış) yerleştirmek ana hat akışına açıklığı geri getirebilir.

İkinci önemli husus, yalnızca uzun bir işlevin yerel bir uzantısında kullanılması amaçlanan değişkenlerin kapsamını kontrol etmektir. Bu tür bir hata derleme ya da çalışma zamanı hatası olarak görünmeyeceğinden, istemeden başka bir yere (örneğin, düzenleme döngülerinden sonra) referans verilen kodun bir bölümünde tanıtılan bir değişkenin bulunmaması için dikkatli olmak gerekir.

Bazı dillerde, bu sorun kolayca önlenir: Yerel bir kod dizisi kendi bloğuna, örneğin yeni girilen değişkenlerin yalnızca bu bloğa göründüğü "{...}" gibi sarılabilir. Python gibi bazı diller bu özellikten yoksundur; bu durumda yerel işlevler daha küçük kapsam bölgelerini zorlamak için yararlı olabilir.

Hayır, çok sayfalı işlevler istenmez ve kod incelemesini geçmemelidir. Ben de uzun fonksiyonlar yazıyordum, ancak Martin Fowler's Refactoring'i okuduktan sonra durdum. Uzun fonksiyonların doğru yazılması, anlaşılması zor ve test edilmesi güçtür. 50 satırdan bile daha kolay anlaşılamayacak ve daha küçük fonksiyonlara ayrılacaksa test edilemeyecek bir fonksiyon görmemiştim. Çok sayfalı bir fonksiyonda, kesinlikle kesinlikle dışlanması gereken tüm sınıflar vardır. Daha spesifik olmak zor. Belki de uzun fonksiyonlarınızdan birini Code Review'a göndermelisiniz ve birisi (belki ben) size nasıl geliştireceğinizi gösterebilir.

Python'da programlama yaparken, bir işlev yazdıktan ve kendime "Zen Python" a uyup uymadığını sorduktan sonra geri adım atmayı seviyorum (python tercümanınıza 'içe aktarın' yazın):

Güzel, çirkin olmaktan iyidir.
Açık, örtük olmaktan iyidir.
Basit, karmaşıktan daha iyidir.
Karmaşık karmaşıktan daha iyidir.
Düz iç içe daha iyidir.
Seyreklik yoğun olmaktan iyidir.
Okunabilirlik sayar.
Özel durumlar kuralları ihlal edecek kadar özel değil.
Her ne kadar pratiklik saflığı yenerse de.
Hatalar asla sessizce geçmemelidir.
Açıkça susturmadıkça.
Belirsizlik karşısında, tahmin etme isteğini reddetmek.
Bunu yapmanın bir yolu ve tercihen sadece bir tane olmalı.
Hollandalı olmadıkça bu yol ilk başta belli olmayabilir.
Şimdi hiç olmadığı kadar iyidir.
Her zaman asla doğrudan daha iyi olmamasına rağmenşimdi.
Uygulamanın açıklanması zorsa, bu kötü bir fikirdir.
Uygulamanın açıklanması kolay ise, iyi bir fikir olabilir.
İsim boşlukları harika bir fikirdir - hadi daha fazlasını yapalım!

Onları ayrı bir modüle koyun.

Çözümünüzün çok fazla seçeneğiniz olmadığından, ihtiyaç duyduğunuzdan daha fazla şişirilmediğini farz edersiniz. İşlevleri zaten farklı alt işlevlerde böldünüz, bu nedenle soru nereye koymanız gerektiğidir:

1. Bunları sadece bir "public" işlevine sahip bir modüle yerleştirin.
2. Bunları yalnızca bir "public" (statik) işlevi olan bir sınıfa yerleştirin.
3. Onları bir işleve yerleştirin (açıkladığınız gibi).

Şimdi hem ikinci hem de üçüncü alternatifler bir anlamda iç içe geçiyor, ancak ikinci alternatif bazı programcılar tarafından kötü görünmüyor. İkinci alternatifi ekarte etmezseniz, üçüncü ekarte etmek için çok fazla sebep göremiyorum.