Berapa panjang ideal metode untuk Anda? [Tutup]


122

Dalam pemrograman berorientasi objek, tentu saja tidak ada aturan pasti tentang panjang maksimum metode, tetapi saya masih menemukan dua kutipan ini agak saling bertentangan, jadi saya ingin mendengar pendapat Anda.

Dalam Clean Code: A Handbook of Agile Software Craftsmanship , Robert Martin mengatakan:

Aturan fungsi pertama adalah bahwa mereka harus kecil. Aturan fungsi kedua adalah mereka harus lebih kecil dari itu. Fungsinya tidak boleh lebih dari 100 baris. Fungsinya hampir tidak boleh sepanjang 20 baris.

dan dia memberikan contoh dari kode Java yang dilihatnya dari Kent Beck:

Setiap fungsi dalam programnya hanya dua, atau tiga, atau empat baris. Masing-masing jelas secara transparan. Masing-masing bercerita. Dan masing-masing membawa Anda ke yang berikutnya dengan urutan yang menarik. Seharusnya sesingkat apa fungsi Anda!

Ini terdengar hebat, tetapi di sisi lain, dalam Code Complete , Steve McConnell mengatakan sesuatu yang sangat berbeda:

Rutin harus dibiarkan tumbuh secara organik hingga 100-200 baris, bukti selama beberapa dekade mengatakan bahwa rutinitas dengan panjang seperti itu tidak lebih rawan kesalahan daripada rutinitas yang lebih pendek.

Dan dia memberikan referensi untuk penelitian yang mengatakan rutinitas 65 baris atau lebih lama lebih murah untuk dikembangkan.

Jadi, sementara ada perbedaan pendapat tentang masalah ini, adakah praktik terbaik fungsional untuk Anda?


17
Fungsi harus mudah dimengerti. Panjangnya harus mengikuti itu, tergantung pada keadaan.
Henk Holterman

56
Saya pikir batas sebenarnya ada di 53 baris. Dengan ukuran garis rata-rata 32,4 karakter. Serius, tidak ada jawaban pasti. Metode 100 baris bisa sangat jelas dan dapat dipelihara, dan metode 4 baris bisa menjadi mimpi buruk untuk dipahami. Namun secara umum, metode panjang cenderung memiliki terlalu banyak tanggung jawab, dan lebih sulit untuk dipahami dan dipelihara daripada yang lebih kecil. Saya akan berpikir dalam hal tanggung jawab, dan mencoba untuk memiliki satu tanggung jawab per metode.

23
Ada istilah dalam pemrograman yang disebut "koherensi fungsional". Panjang fungsi harus dibiarkan bervariasi asalkan implementasinya masih merupakan satu unit logika yang koheren dalam aplikasi Anda. Membagi fungsi secara sewenang-wenang untuk membuatnya lebih kecil cenderung memperbesar kode Anda dan merusak pemeliharaan.

9
Dan, jika Anda ingin membatasi kompleksitas fungsi Anda, Anda harus mengukur kompleksitas siklomatiknya , bukan panjangnya. Sebuah switchpernyataan dengan 100 casekondisi yang lebih dipertahankan dari 10 tingkat dari ifpernyataan bersarang dalam satu sama lain.

10
Pendekatan Bob Martin berasal dari 2008, Steve Mc Connell dari 1993. Mereka memiliki filosofi yang berbeda tentang apa "kode yang baik" itu, dan IMHO Bob Martin mencoba untuk memperoleh tingkat kualitas kode yang jauh lebih tinggi.
Doc Brown

Jawaban:


115

Fungsinya biasanya singkat, antara 5-15 baris adalah "aturan praktis" pribadi saya ketika menulis kode di Java atau C #. Ini adalah ukuran yang baik karena beberapa alasan:

  • Ini cocok dengan mudah di layar Anda tanpa menggulir
  • Ini tentang ukuran konseptual yang dapat Anda pegang di kepala Anda
  • Cukup bermakna untuk membutuhkan fungsi dalam dirinya sendiri (sebagai logika yang berdiri sendiri dan bermakna)
  • Fungsi yang lebih kecil dari 5 baris adalah petunjuk bahwa Anda mungkin terlalu banyak memecah kode (yang membuatnya lebih sulit untuk dibaca / dipahami jika Anda perlu menavigasi antar fungsi). Entah itu atau Anda lupa kasus khusus / penanganan kesalahan!

Tapi saya pikir itu tidak membantu untuk menetapkan aturan absolut, karena akan selalu ada pengecualian / alasan yang valid untuk menyimpang dari aturan:

  • Fungsi accessor satu garis yang melakukan pemeran tipe jelas dapat diterima dalam beberapa situasi.
  • Ada beberapa fungsi yang sangat singkat namun bermanfaat (mis. Swap seperti yang disebutkan oleh pengguna tidak diketahui) yang jelas membutuhkan kurang dari 5 baris. Bukan masalah besar, beberapa fungsi 3 baris tidak membahayakan basis kode Anda.
  • Fungsi 100-line yang merupakan pernyataan switch besar tunggal mungkin dapat diterima jika sangat jelas apa yang sedang dilakukan. Kode ini dapat secara konsep sangat sederhana bahkan jika memerlukan banyak baris untuk menggambarkan berbagai kasus. Kadang-kadang disarankan bahwa ini harus di refactored ke dalam kelas yang terpisah dan diimplementasikan menggunakan pewarisan / polimorfisme tetapi IMHO ini mengambil OOP terlalu jauh - saya lebih suka hanya memiliki satu pernyataan peralihan 40 arah yang besar daripada 40 kelas baru yang harus ditangani, selain itu ke pernyataan switch 40-arah untuk membuatnya.
  • Fungsi kompleks mungkin memiliki banyak variabel status yang akan menjadi sangat berantakan jika dilewatkan di antara berbagai fungsi sebagai parameter. Dalam hal ini Anda dapat berargumen dengan masuk akal bahwa kode lebih sederhana dan lebih mudah diikuti jika Anda menyimpan semuanya dalam satu fungsi besar (meskipun seperti yang ditunjukkan Mark dengan tepat, ini juga bisa menjadi kandidat untuk berubah menjadi kelas untuk merangkum kedua logika tersebut) dan nyatakan).
  • Terkadang fungsi yang lebih kecil atau lebih besar memiliki keunggulan kinerja (mungkin karena alasan inlining atau JIT seperti yang disebutkan Frank). Ini sangat tergantung pada implementasi, tetapi dapat membuat perbedaan - pastikan Anda membuat tolok ukur!

Jadi pada dasarnya, gunakan akal sehat , pertahankan ukuran fungsi kecil di sebagian besar kasus tetapi jangan dogmatis tentang hal itu jika Anda memiliki alasan yang benar-benar bagus untuk membuat fungsi yang luar biasa besar.


9
Ada alasan teknis / perf untuk metode pendek, juga: hit cache JIT. Banyak metode yang lebih kecil dan dapat digunakan kembali lebih mungkin telah dipanggil sebelumnya. Oh dan manfaat diag tambahan, StackTraces lebih fokus pada logika yang muncul.
Luke Puplett

20
"gunakan akal sehat" adalah saran yang paling penting
Simon

Orang harus menyadari bahwa heuristik ini akan menghasilkan keluhan "kode ravioli" karena kedalaman tumpukan di breakpoints, ketika debugging.
Frank Hileman

5
@FrankHileman Saya akan mengambil ravioli di atas spaghetti setiap hari ketika menulis kode

1
@Snowman: pilihan ini tidak saling eksklusif ... kedalaman tumpukan pendek tanpa spaghetti adalah yang ideal. Kedalaman tumpukan yang dalam, dengan spageti di samping?
Frank Hileman

30

Sementara saya setuju dengan komentar orang lain ketika mereka mengatakan tidak ada aturan keras tentang nomor LOC yang tepat, saya bertaruh jika kita melihat kembali proyek yang telah kita lihat di masa lalu dan mengidentifikasi setiap fungsi di atas, katakanlah 150 baris kode, saya ' Saya kira kita akan sampai pada konsensus bahwa 9 dari 10 fungsi tersebut merusak SRP (dan sangat mungkin juga OCP), memiliki terlalu banyak variabel lokal, aliran kontrol terlalu banyak dan umumnya sulit dibaca dan dipelihara.

Jadi, meskipun LOC mungkin bukan indikator langsung kode buruk, tentu indikator tidak langsung yang layak bahwa fungsi tertentu dapat ditulis lebih baik.

Di tim saya, saya jatuh ke posisi memimpin dan untuk alasan apa pun, orang-orang tampaknya mendengarkan saya. Apa yang biasanya saya setujui adalah untuk memberi tahu tim bahwa meskipun tidak ada batasan absolut, fungsi apa pun lebih dari 50 baris kode minimal harus menaikkan bendera merah selama peninjauan kode, sehingga kami melihatnya kembali dan mengevaluasi kembali untuk kompleksitas dan pelanggaran SRP / OCP. Setelah pandangan kedua, kita mungkin membiarkannya sendiri atau mengubahnya, tetapi setidaknya itu membuat orang berpikir tentang hal-hal ini.


3
Ini tampaknya masuk akal - LOC tidak berarti apa-apa sehubungan dengan kompleksitas atau kualitas kode, tetapi ini bisa menjadi penanda yang baik untuk kemungkinan bahwa hal-hal yang harus di refactored.
cori

4
"sampai pada konsensus bahwa 9 dari 10 fungsi tersebut merusak SRP" - Saya tidak setuju, saya cukup yakin 10 dari 10 fungsi itu akan merusaknya ;-)
Doc Brown

1
+1 untuk mengibarkan bendera selama peninjauan kode: dengan kata lain, bukan aturan yang keras dan cepat, tetapi mari kita bahas kode ini sebagai grup.

22

Saya melangkah ke proyek yang tidak peduli tentang pedoman pengkodean. Ketika saya melihat kode saya kadang-kadang menemukan kelas dengan lebih dari 6000 baris kode dan kurang dari 10 metode. Ini adalah skenario horor ketika Anda harus memperbaiki bug.

Aturan umum tentang seberapa besar suatu metode harus maksimal kadang-kadang tidak begitu baik. Saya suka aturan oleh Robert C. Martin (Paman Bob): "Metode harus kecil, lebih kecil dari kecil". Saya mencoba menggunakan aturan ini setiap saat. Saya mencoba untuk menjaga metode saya sederhana dan kecil dengan mengklarifikasi bahwa metode saya hanya melakukan satu hal dan tidak lebih.


4
Saya tidak melihat mengapa fungsi 6.000 baris lebih sulit untuk di-debug daripada yang lebih pendek ... Kecuali jika ia memiliki masalah lain juga (mis. Pengulangan)
Calmarius

17
Ini tidak ada hubungannya dengan debugging .. ini tentang kompleksitas dan perawatan. Bagaimana Anda akan memperluas atau mengubah metode 6000 baris yang dilakukan oleh yang lain?
Smokefoot

10
@Calmarius perbedaannya biasanya 6000 fungsi garis cenderung mengandung variabel lokal yang dinyatakan sangat jauh (secara visual), sehingga menyulitkan programmer untuk membangun konteks mental yang diperlukan untuk memiliki kepercayaan diri yang tinggi tentang kode. Bisakah Anda yakin tentang bagaimana variabel diinisialisasi dan dibangun pada titik tertentu? Apakah Anda yakin tidak ada yang akan mengacaukan variabel Anda setelah Anda mengaturnya di baris 3879? Di sisi lain, dengan 15 metode garis, Anda bisa yakin.
Daniel B

8
@Calmarius setuju, tetapi kedua pernyataan tersebut merupakan argumen terhadap 6000 fungsi LOC.
Daniel B

2
Variabel lokal dalam metode 600 baris pada dasarnya adalah variabel global.
MK01

10

Ini bukan tentang jumlah baris, ini tentang SRP. Menurut prinsip ini, metode Anda harus melakukan satu dan hanya satu hal.

Jika metode Anda melakukan ini DAN ini DAN ini ATAU itu => itu mungkin melakukan banyak hal. Cobalah untuk melihat metode ini dan menganalisis: "di sini saya mendapatkan data ini, mengurutkannya dan mendapatkan elemen yang saya butuhkan" dan "di sini saya memproses elemen-elemen ini" dan "di sini saya akhirnya menggabungkan mereka untuk mendapatkan hasilnya". "Blok" ini harus di refactored ke metode lain.

Jika Anda hanya mengikuti SRP sebagian besar metode Anda akan kecil dan dengan niat yang jelas.

Tidak benar mengatakan "metode ini> 20 baris jadi itu salah". Hal ini dapat merupakan indikasi bahwa sesuatu mungkin salah dengan metode ini, tidak lebih.

Anda mungkin memiliki 400 saluran beralih dalam suatu metode (sering terjadi di telekomunikasi), dan itu masih tanggung jawab tunggal dan itu benar-benar OK.


2
Pernyataan pergantian besar, pemformatan keluaran, definisi hash / kamus yang harus di-hardcode daripada fleksibel di beberapa basis data, ini sering terjadi, dan baik-baik saja. Selama logika itu dibagi, maka Anda semua baik-baik saja. Metode besar dapat meminta Anda untuk berpikir 'haruskah saya membagi ini'. Jawabannya bisa sangat 'tidak, ini baik-baik saja' (atau ya, ini benar-benar berantakan)
Martijn

Apa artinya "SRP"?
thomthom

3
SRP adalah singkatan dari Single Responsibility Principle dan menyatakan bahwa setiap kelas (atau metode) seharusnya hanya memiliki satu tanggung jawab. Ini terkait dengan kohesi dan kopling. Jika Anda mengikuti SRP, kelas Anda (atau metode) akan memiliki kohesi yang baik, tetapi kopling dapat meningkat karena Anda berakhir dengan lebih banyak kelas (atau metode).
Kristian Duske

+1 untuk SRP. Dengan menulis fungsi kohesif, maka seseorang dapat lebih mudah menggabungkannya dalam gaya fungsional untuk mencapai hasil yang lebih kompleks. Pada akhirnya lebih baik bahwa suatu fungsi terdiri dari tiga fungsi lain yang direkatkan daripada memiliki fungsi tunggal yang melakukan tiga hal yang terpisah, bahkan jika ada hubungannya.
Mario T. Lanza

Ya tapi apa yang menjadi tanggung jawab tunggal. Itu hanya konsep yang dibuat di kepala Anda. Jika Anda memerlukan 400 baris untuk satu tanggung jawab, konsep tanggung jawab tunggal Anda mungkin jauh berbeda dari saya
Xitcod13

9

Tergantung , serius, benar-benar tidak ada jawaban yang solid untuk pertanyaan ini karena bahasa Anda bekerja dengan masalah, lima sampai lima belas baris yang disebutkan dalam jawaban ini mungkin bekerja untuk C # atau Java, tetapi dalam bahasa lain itu tidak memberikan Anda banyak bekerja dengan. Demikian juga, tergantung pada domain tempat Anda bekerja, Anda mungkin menemukan diri Anda menulis nilai pengaturan kode dalam struktur data yang besar. Dengan beberapa struktur data Anda mungkin memiliki puluhan elemen yang perlu Anda atur, haruskah Anda membagi beberapa hal ke fungsi yang terpisah hanya karena fungsi Anda berjalan lama?

Seperti yang telah dicatat orang lain, aturan praktis yang terbaik adalah bahwa suatu fungsi harus berupa entitas logis tunggal yang menangani satu tugas. Jika Anda mencoba untuk menegakkan aturan kejam yang mengatakan bahwa fungsi tidak boleh lebih dari n baris dan Anda membuat nilai itu terlalu kecil kode Anda akan tumbuh lebih sulit untuk dibaca karena pengembang mencoba dan menggunakan trik mewah untuk menyiasati aturan. Demikian juga, jika Anda mengaturnya terlalu tinggi itu akan menjadi masalah dan dapat menyebabkan kode yang buruk meskipun malas. Taruhan terbaik Anda adalah dengan hanya melakukan tinjauan kode untuk memastikan bahwa fungsi menangani satu tugas dan membiarkannya begitu saja.


8

Saya pikir satu masalah di sini adalah bahwa panjang fungsi tidak mengatakan apa-apa tentang kerumitannya. LOC (Lines of Code) adalah instrumen yang buruk untuk mengukur apa pun.

Suatu metode seharusnya tidak terlalu rumit, tetapi ada skenario di mana metode yang panjang dapat dengan mudah dipelihara. Perhatikan bahwa contoh berikut tidak mengatakan itu tidak dapat dibagi menjadi metode, hanya saja metode tidak akan mengubah rawatan.

misalnya handler untuk data yang masuk dapat memiliki pernyataan saklar besar dan kemudian kode sederhana per kasus. Saya memiliki kode seperti itu - mengelola data yang masuk dari umpan. 70 (!) Penangan berkode angka. Sekarang, orang akan mengatakan "gunakan konstanta" - ya, kecuali API tidak menyediakannya dan saya ingin tetap dekat dengan "sumber" di sini. Metode? Tentu - sayangnya semuanya berurusan dengan data dari 2 struktur besar yang sama. Tidak ada manfaat dalam memisahkan mereka kecuali mungkin memiliki lebih banyak metode (keterbacaan). Kode ini secara intrinsik tidak rumit - satu sakelar, tergantung pada satu bidang. Kemudian setiap case memiliki blok yang mem-parsing x elemen data dan mempublikasikannya. Tidak ada mimpi buruk pemeliharaan. Ada satu pengulangan "jika kondisi yang menentukan apakah suatu bidang memiliki data (pField = pFields [x], jika pField-> IsSet () {blabla}) - hampir sama untuk setiap bidang ..

Ganti itu dengan rutin yang jauh lebih kecil yang mengandung nested loop dan banyak pernyataan pergantian yang nyata dan metode besar bisa lebih mudah dipelihara daripada yang lebih kecil.

Jadi, maaf, LOC bukanlah pengukuran yang baik untuk memulai. Jika ada, maka poin kompleksitas / keputusan harus digunakan.


1
LOC adalah alat yang baik untuk digunakan untuk satu bidang di mana mereka memberikan ukuran yang relevan - proyek yang sangat besar di mana mereka dapat digunakan untuk membantu memberikan perkiraan berapa lama proyek yang sama mungkin perlu diselesaikan. Di luar itu, orang cenderung terlalu mengkhawatirkan mereka.
rjzii

Baik. Ini tidak seperti LOC tidak melaporkan waktu yang tepat pada seberapa ekspresif saya menulis kode, pada hformatting rquirements dll. LOC benar-benar tidak cocok dan kadang-kadang bahwa MBA tanpa menggunakan pengalaman menggunakan. Hanya. Anda bebas untuk memasukkan diri Anda ke dalam daftar orang yang tidak mengerti mengapa LOC adalah ukuran yang buruk, tetapi jelas itu tidak akan membuat Anda terlihat sebagai seseorang untuk didengarkan.
TomTom

Harap tinjau kembali apa yang saya katakan, saya mencatat bahwa LOC adalah alat yang baik hanya untuk satu bidang pengukuran dan penggunaan (yaitu proyek yang sangat besar di mana mereka dapat digunakan untuk estimasi). Apa pun yang lebih kecil dari skala besar dan mereka menggunakan sebagian besar jika tidak semua nilai untuk apa pun di luar gigitan suara cepat dalam rapat untuk membuat orang senang. Mereka seperti mencoba menggunakan tahun cahaya untuk mengukur seberapa adil kedai kopi dari kantor, tentu Anda bisa melakukannya, tetapi pengukurannya tidak berguna. Tetapi ketika Anda perlu mendiskusikan jarak antar bintang, mereka bekerja dengan sangat baik.
rjzii

2
+1 fungsi harus memiliki semua kode yang diperlukan untuk menjalankan fungsi. Seharusnya melakukan satu hal dan satu hal saja - tetapi jika itu membutuhkan 1000 baris kode maka jadilah itu.
James Anderson

Saya telah menulis penangan untuk data soket yang masuk dan ya, mereka dapat membutuhkan seribu atau lebih LOC. Namun, saya dapat menghitung di satu sisi berapa kali saya perlu melakukan itu dan tidak dapat menghitung berapa kali itu bukan cara yang tepat untuk kode.

7

Saya hanya akan memberikan penawaran lain.

Program harus ditulis untuk dibaca orang, dan hanya secara kebetulan untuk dijalankan mesin

- Harold Abelson

Sangat tidak mungkin bahwa fungsi yang tumbuh hingga 100-200 mengikuti aturan ini


1
Kecuali ketika mereka berisi saklar.
Calmarius

1
atau buat objek berdasarkan hasil kueri basis data yang mengembalikan lusinan bidang per baris di ...
jwenting

Hasil-hasil basis data tentu saja merupakan pengecualian yang dapat diterima - ditambah lagi mereka biasanya pernyataan "bodoh" yang mengisi beberapa instance kelas (atau apa pun), daripada logika daripada yang harus diikuti.
MetalMikester

6

Saya sudah berada di raket gila ini, entah bagaimana, sejak 1970.

Dalam semua waktu itu, dengan dua pengecualian yang akan saya bahas sebentar lagi, saya TIDAK PERNAH melihat "rutin" yang dirancang dengan baik (metode, prosedur, fungsi, subrutin, apa pun) yang PERLU menjadi lebih dari satu halaman yang dicetak ( sekitar 60 baris) panjangnya. Sebagian besar dari mereka agak sedikit pendek, pada urutan 10-20 baris.

Namun, saya telah melihat BANYAK kode "aliran kesadaran", yang ditulis oleh orang-orang yang tampaknya tidak pernah mendengar modularisasi.

Dua pengecualian adalah kasus yang sangat khusus. Yang satu sebenarnya adalah kelas kasus pengecualian, yang saya gabungkan bersama: automata negara-terbatas besar, diimplementasikan sebagai pernyataan peralihan yang jelek, biasanya karena tidak ada cara yang lebih bersih untuk mengimplementasikannya. Hal-hal ini biasanya muncul di peralatan uji otomatis, parsing data log dari perangkat yang diuji.

Yang lainnya adalah foton torpedo rutin dari game STARTRK Matuszek-Reynolds-McGehearty-Cohen, yang ditulis dalam CDC 6600 FORTRAN IV. Itu harus mengurai baris perintah, kemudian mensimulasikan penerbangan masing-masing torpedo, dengan gangguan, memeriksa interaksi antara torpedo dan setiap jenis benda yang bisa mengenai, dan oh dengan cara mensimulasikan rekursi untuk melakukan konektivitas 8 arah pada rantai novae dari torpedo bintang yang di sebelah bintang lainnya.


2
+1 untuk getaran "turun dari halaman saya" yang saya dapatkan dari jawaban ini. Juga, dari pengalaman pribadi dari sebelum bahasa OOP tersebar luas.

Itu tidak begitu banyak "turun dari halaman saya" sebagai pengamatan bahwa saya telah melihat BANYAK kode omong kosong selama bertahun-tahun, dan tampaknya semakin buruk.
John R. Strohm

Bos saya memiliki kebiasaan menulis metode beberapa ratus baris, sering dengan beberapa tingkat bersarang. Dia juga menggunakan kelas parsial (.NET) untuk "memecah" kelas menjadi beberapa file sehingga dia dapat mengklaim bahwa dia menjaga mereka pendek. Itu hanya dua hal yang harus saya tangani. Sudah melakukan ini selama sekitar 25 tahun, dan saya dapat mengkonfirmasi bahwa semuanya semakin buruk. Dan sekarang saatnya bagi saya untuk kembali ke kekacauan itu.
MetalMikester

5

Jika saya menemukan metode yang panjang, saya bisa bertaruh metode ini tidak diuji unit dengan benar atau sebagian besar waktu tidak memiliki uji unit sama sekali. Jika Anda mulai melakukan TDD, Anda tidak akan pernah membangun metode 100-baris dengan 25 tanggung jawab berbeda dan 5 loop bersarang. Tes mengharuskan Anda terus-menerus memperbaiki kekacauan Anda dan menulis kode bersih paman Bob.


2

Tidak ada aturan mutlak tentang panjang metode, tetapi aturan berikut ini bermanfaat:

  1. Tujuan utama fungsi adalah untuk menemukan nilai balik. Tidak ada alasan lain untuk keberadaannya. Setelah alasan itu terpenuhi, tidak ada kode lain yang harus dimasukkan ke dalamnya. Ini tentu membuat fungsi kecil. Memanggil fungsi lain hanya boleh dilakukan jika itu membuat menemukan nilai kembali lebih mudah.
  2. Di sisi lain, antarmuka harus kecil. Ini berarti Anda memiliki banyak kelas, atau Anda memiliki fungsi besar - salah satu dari keduanya akan terjadi setelah Anda mulai memiliki kode yang cukup untuk melakukan sesuatu yang signifikan. Program besar dapat memiliki keduanya.

1
Bagaimana dengan efek samping - menulis ke file, mengatur ulang status, dll.?
Vorac

2

Apakah penulis mengartikan hal yang sama dengan "fungsi" dan "rutin"? Biasanya ketika saya mengatakan "fungsi" yang saya maksud adalah subrutin / operasi yang mengembalikan nilai dan "prosedur" untuk yang tidak (dan yang panggilannya menjadi pernyataan tunggal). Ini bukan perbedaan umum di seluruh SE di dunia nyata tetapi saya telah melihatnya di teks pengguna.

Either way, tidak ada jawaban yang tepat untuk ini. Preferensi untuk satu atau yang lain (jika ada preferensi sama sekali) adalah sesuatu yang saya harapkan akan sangat berbeda antara bahasa, proyek, dan organisasi; seperti halnya dengan semua konvensi kode.

Satu hal yang saya tambahkan adalah bahwa keseluruhan "operasi panjang tidak lebih rentan kesalahan daripada operasi pendek" pernyataan tidak sepenuhnya benar. Selain fakta bahwa lebih banyak kode sama dengan lebih banyak ruang kesalahan potensial, sangat jelas bahwa memecah kode menjadi segmen akan membuat kesalahan lebih mudah untuk dihindari dan lebih mudah ditemukan. Kalau tidak, tidak akan ada alasan untuk memecah kode menjadi beberapa bagian, simpan pengulangan. Tapi ini mungkin benar hanya jika segmen tersebut didokumentasikan dengan cukup baik sehingga Anda dapat menentukan hasil dari panggilan operasi tanpa membaca atau melacak kode aktual (desain-kontrak berdasarkan spesifikasi daripada ketergantungan nyata antara bidang kode).

Selain itu, jika Anda ingin operasi yang lebih lama bekerja dengan baik, Anda mungkin ingin mengadopsi konvensi kode yang lebih ketat untuk mendukungnya. Melemparkan pernyataan kembali di tengah operasi mungkin baik untuk operasi pendek, tetapi dalam operasi yang lebih lama ini dapat membuat bagian besar kode yang bersyarat tetapi tidak jelas bersyarat pada pembacaan cepat (hanya untuk satu contoh).

Jadi saya akan berpikir bahwa gaya mana yang cenderung menjadi mimpi buruk yang dipenuhi bug sebagian besar akan tergantung pada konvensi apa yang Anda patuhi untuk sisa kode Anda. :)


1

IMHO, Anda tidak perlu menggunakan scrollbar untuk membaca fungsi Anda. Segera setelah Anda perlu memindahkan bilah gulir, perlu beberapa saat lagi untuk memahami cara kerja fungsinya.

Dengan demikian, itu tergantung pada lingkungan pemrograman yang biasa dari kerja tim Anda (resolusi layar, editor, ukuran font, dll ...). Di 80-an, itu 25 baris dan 80 kolom. Sekarang, pada editor saya, saya menampilkan hampir 50 baris. Jumlah kolom yang saya tampilkan tidak berubah karena saya membagi layar saya menjadi dua untuk menampilkan dua file sekaligus.

Singkatnya, itu tergantung pengaturan rekan kerja Anda.


2
Bukannya 24 baris waktu itu? Saya sedang memikirkan 3270 atau 9750 terminal, di mana tanggal 25 adalah garis status. Dan emulasi terminal mengikuti ini.
ott--

beberapa sistem / editor memiliki 40 atau 50 baris dari awal. Saat ini 150 baris tidak jarang dan 200+ dapat dilakukan, jadi itu bukan metrik yang bagus.
Móż

Saya menggunakan layar saya dalam orientasi potret, saya dapat melihat 200 baris kode sekaligus.
Calmarius

dan jika saya tidak menggunakan jeda baris apa pun untuk memecah baris saya, saya dapat mengkode metode 5.000 baris dalam satu baris ...
jwenting

1

Saya pikir jawaban TomTom mendekati perasaan saya tentang hal itu.

Semakin banyak saya mendapati diri saya melakukan kompleksitas siklomatik daripada garis.

Saya biasanya bertujuan untuk tidak lebih dari satu struktur kontrol per metode, dengan pengecualian dari berapa banyak loop yang diperlukan untuk menangani array multi-dimensi.

Saya kadang-kadang menemukan diri saya meletakkan seandainya satu-baris dalam kasus beralih karena untuk beberapa alasan ini cenderung menjadi kasus di mana membaginya menghalangi daripada membantu.

Perhatikan bahwa saya tidak menghitung logika penjaga terhadap batas ini.


Kompleksitas siklomatik telah ditunjukkan, pada sejumlah besar kode produksi nyata, sangat SANGAT berkorelasi dengan SLOC mentah, menjadikan komputasi kompleksitas siklomatik sebagai pemborosan waktu, energi, dan siklus clock.
John R. Strohm

@ JohnR.Strohm yang saya bicarakan per metode, tidak secara keseluruhan. Tentu, dalam gambaran besar itu sangat berkorelasi - pertanyaannya adalah bagaimana membagi kode itu menjadi metode. 10 metode 100 baris atau 100 metode 10 baris masih akan memiliki SLOC dan kompleksitas keseluruhan yang sama tetapi yang pertama akan jauh lebih sulit untuk dikerjakan.
Loren Pechtel

saya juga. Studi korelasi melihat BANYAK kode, dan BANYAK rutinitas. (Itu adalah salah satu repositori publik besar.)
John R. Strohm

-3

Dalam OOP semua benda keberatan dan ada fitur-fitur ini:

  1. Polimorfisme
  2. Abstraksi
  3. Warisan

Ketika Anda mematuhi aturan-aturan ini maka metode Anda biasanya kecil tetapi tidak ada aturan untuk aturan kecil atau sangat kecil (misalnya 2-3 baris). Manfaat metode kecil (unit kecil misalnya metode atau fungsi) adalah:

  1. lebih mudah dibaca
  2. pertahankan lebih baik
  3. memperbaiki bug lebih baik
  4. berubah lebih baik
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.