Berapa banyak parameter yang terlalu banyak? [Tutup]

Rutinitas dapat memiliki parameter, itu bukan berita. Anda dapat menetapkan sebanyak mungkin parameter yang Anda butuhkan, tetapi terlalu banyak parameter akan membuat rutinitas Anda sulit dipahami dan dipelihara.

Tentu saja, Anda bisa menggunakan variabel terstruktur sebagai solusinya: menempatkan semua variabel tersebut dalam satu struct dan meneruskannya ke rutin. Bahkan, menggunakan struktur untuk menyederhanakan daftar parameter adalah salah satu teknik yang dijelaskan oleh Steve McConnell dalam Code Complete . Tapi seperti katanya:

Pemrogram yang berhati-hati menghindari penggabungan data lebih dari yang diperlukan secara logis.

Jadi jika rutin Anda memiliki terlalu banyak parameter atau Anda menggunakan struct untuk menyamarkan daftar parameter besar, Anda mungkin melakukan sesuatu yang salah. Artinya, Anda tidak membuat sambungan longgar.

Pertanyaan saya adalah, kapan saya bisa menganggap daftar parameter terlalu besar? Saya pikir lebih dari 5 parameter, terlalu banyak. Bagaimana menurut anda?

Kapan sesuatu dianggap sangat cabul sebagai sesuatu yang dapat diatur meskipun Amandemen 1 menjamin kebebasan berbicara? Menurut Justice Potter Stewart, "Saya tahu itu ketika saya melihatnya." Hal yang sama berlaku di sini.

Saya benci membuat aturan yang keras dan cepat seperti ini karena jawaban berubah tidak hanya tergantung pada ukuran dan ruang lingkup proyek Anda, tetapi saya pikir itu berubah bahkan ke tingkat modul. Bergantung pada apa yang dilakukan metode Anda, atau apa yang seharusnya diwakili oleh kelas, sangat mungkin bahwa 2 argumen terlalu banyak dan merupakan gejala dari terlalu banyak kopling.

Saya akan menyarankan bahwa dengan mengajukan pertanyaan di tempat pertama, dan memenuhi syarat pertanyaan Anda sebanyak yang Anda lakukan, bahwa Anda benar-benar tahu semua ini. Solusi terbaik di sini adalah tidak bergantung pada angka yang keras dan cepat, tetapi sebaliknya melihat ke tinjauan desain dan ulasan kode di antara rekan-rekan Anda untuk mengidentifikasi area di mana Anda memiliki kohesi rendah dan kopling ketat.

Jangan pernah takut menunjukkan kepada rekan kerja pekerjaan Anda. Jika Anda takut, itu mungkin pertanda lebih besar bahwa ada sesuatu yang salah dengan kode Anda, dan Anda sudah mengetahuinya .

Suatu fungsi hanya dapat memiliki terlalu banyak parameter jika beberapa parameternya berlebihan. Jika semua parameter digunakan, fungsi harus memiliki jumlah parameter yang benar. Ambil fungsi yang sering digunakan ini:

HWND CreateWindowEx
(
  DWORD dwExStyle,
  LPCTSTR lpClassName,
  LPCTSTR lpWindowName,
  DWORD dwStyle,
  int x,
  int y,
  int nWidth,
  int nHeight,
  HWND hWndParent,
  HMENU hMenu,
  HINSTANCE hInstance,
  LPVOID lpParam
);

Itu 12 parameter (9 jika Anda menggabungkan x, y, w dan h sebagai persegi panjang) dan ada juga parameter yang berasal dari nama kelas juga. Bagaimana Anda mengurangi ini? Apakah Anda ingin mengurangi jumlah lebih banyak ke titik?

Jangan biarkan jumlah parameter mengganggu Anda, pastikan itu logis dan didokumentasikan dengan baik dan biarkan intellisense ^* membantu Anda.

^* Asisten coding lain tersedia!

Dalam Clean Code , Robert C. Martin mengabdikan empat halaman untuk subjek. Inilah intinya:

Jumlah ideal argumen untuk suatu fungsi adalah nol (niladik). Berikutnya adalah satu (monadik), diikuti oleh dua (diad). Tiga argumen (triadik) harus dihindari jika memungkinkan. Lebih dari tiga (polyadic) membutuhkan pembenaran yang sangat khusus - dan karenanya tidak seharusnya digunakan.

Beberapa kode yang pernah saya gunakan sebelumnya menggunakan variabel global hanya untuk menghindari terlalu banyak melewati parameter.

Tolong jangan lakukan itu!

(Biasanya.)

Jika Anda mulai harus menghitung secara mental parameter dalam tanda tangan dan mencocokkannya dengan panggilan, maka sekarang saatnya untuk refactor!

Terima kasih banyak atas semua jawaban Anda:

• Agak mengejutkan menemukan orang yang juga berpikir (seperti yang saya lakukan) bahwa 5 parameter adalah batas yang baik untuk kewarasan kode.

• Secara umum, orang cenderung setuju bahwa batasan antara 3 dan 4 adalah aturan praktis yang baik. Ini masuk akal karena orang biasanya memiliki waktu yang buruk menghitung lebih dari 4 hal.

• Seperti yang ditunjukkan Milan , rata-rata orang dapat menyimpan kurang lebih 7 hal di kepala mereka sekaligus. Tapi saya pikir Anda tidak bisa melupakan itu, ketika Anda merancang / memelihara / mempelajari suatu rutin, Anda harus mengingat lebih banyak hal daripada hanya parameternya.

• Beberapa orang menganggap bahwa rutinitas harus memiliki argumen sebanyak yang diperlukan. Saya setuju, tetapi hanya untuk beberapa kasus tertentu (panggilan ke OS OS, rutinitas di mana optimasi itu penting, dll). Saya menyarankan untuk menyembunyikan kompleksitas dari rutinitas ini dengan menambahkan lapisan abstraksi tepat di atas panggilan ini bila memungkinkan.

• Nick punya beberapa pemikiran menarik tentang ini. Jika Anda tidak ingin membaca komentarnya, saya meringkas untuk Anda: singkatnya, itu tergantung :

  Saya benci membuat aturan yang keras dan cepat seperti ini karena jawaban berubah tidak hanya tergantung pada ukuran dan ruang lingkup proyek Anda, tetapi saya pikir itu berubah bahkan ke tingkat modul. Bergantung pada apa yang dilakukan metode Anda, atau apa yang seharusnya diwakili oleh kelas, sangat mungkin bahwa 2 argumen terlalu banyak dan merupakan gejala dari terlalu banyak kopling.

  Moral di sini adalah jangan takut menunjukkan kode Anda kepada rekan-rekan Anda, berdiskusi dengan mereka dan mencoba untuk "mengidentifikasi area di mana Anda memiliki kohesi yang rendah dan penggabungan yang ketat" .

• Akhirnya, saya pikir wnoise banyak setuju dengan Nick, dan menyimpulkan kontribusi satir dengan visi puitis ini (lihat komentar di bawah) dari seni pemrograman:

  Pemrograman bukan rekayasa. Organisasi kode adalah seni karena tergantung pada faktor manusia, yang terlalu bergantung pada konteks untuk aturan keras apa pun.

Jawaban ini mengasumsikan bahasa OO. Jika Anda tidak menggunakannya - lewati jawaban ini (ini bukan jawaban bahasa-agnostik dengan kata lain.

Jika Anda melewati lebih dari 3 parameter (terutama tipe / objek intrinsik), ini bukan berarti "Terlalu banyak" tetapi Anda mungkin kehilangan kesempatan untuk membuat objek baru.

Cari grup parameter yang dapat diteruskan ke lebih dari satu metode - bahkan grup yang dialihkan ke dua metode hampir menjamin bahwa Anda harus memiliki objek baru di sana.

Kemudian, Anda merevisi fungsionalitas ke objek baru Anda dan Anda tidak akan percaya betapa itu membantu baik kode Anda dan pemahaman Anda tentang pemrograman OO.

Sepertinya ada pertimbangan lain selain angka belaka, berikut beberapa yang terlintas dalam pikiran:

1. hubungan logis dengan tujuan utama fungsi vs pengaturan satu kali

2. Jika itu hanya bendera lingkungan, bundling bisa sangat berguna

Salah satu epigram pemrograman terkenal Alan Perlis (diceritakan dalam ACM SIGPLAN Notices 17 (9), September, 1982) menyatakan bahwa "Jika Anda memiliki prosedur dengan 10 parameter, Anda mungkin melewatkan beberapa."

Menurut Steve McConnell dalam Code Complete , Anda harus melakukannya

Batasi jumlah parameter rutin hingga sekitar tujuh

Bagi saya, ketika daftar melewati satu baris pada IDE saya, maka itu salah satu parameter yang terlalu banyak. Saya ingin melihat semua parameter dalam satu baris tanpa memutus kontak mata. Tapi itu hanya preferensi pribadi saya.

Saya biasanya setuju dengan 5, namun, jika ada situasi di mana saya membutuhkan lebih banyak dan ini adalah cara paling jelas untuk menyelesaikan masalah, maka saya akan menggunakan lebih banyak.

Tujuh hal dalam ingatan jangka pendek?

1. Nama fungsinya
2. Nilai pengembalian fungsi
3. Tujuan fungsinya
4. Parameter 1
5. Parameter 2
6. Parameter 3
7. Parameter 4

Dalam Cuplikan Kode 5 Terburuk , periksa yang kedua, "Apakah ini konstruktor". Ini memiliki lebih dari 37 ⋅ 4 ≈ 150 parameter:

Di sini seorang programmer menulis konstruktor ini [... S] beberapa dari Anda mungkin berpikir ya itu konstruktor besar tetapi ia menggunakan alat pembuat kode gerhana otomatis [.] NOO, dalam konstruktor ini ada bug kecil yang saya temukan, yang membuat saya menyimpulkan bahwa konstruktor ini ditulis dengan tangan. (omong-omong ini hanya bagian atas konstruktor, itu tidak lengkap).

Satu lebih dari yang diperlukan. Saya tidak bermaksud menjadi glib, tetapi ada beberapa fungsi yang perlu beberapa opsi. Sebagai contoh:

void *
mmap(void *addr, size_t len, int prot, int flags, int fildes, off_t offset);

Ada 6 argumen, dan semuanya penting. Selain itu, tidak ada tautan umum di antara mereka untuk membenarkan bundling mereka. Mungkin Anda bisa mendefinisikan "struct mmapargs", tetapi itu akan lebih buruk.

Menurut Perl Best Practices , 3 tidak apa-apa, 4 terlalu banyak. Itu hanya panduan, tetapi di toko kami itulah yang kami coba patuhi.

Saya akan menggambar batas untuk fungsi publik di 5 parameter sendiri.

IMHO, daftar parameter panjang hanya dapat diterima dalam fungsi pembantu pribadi / lokal yang hanya dimaksudkan untuk dipanggil dari beberapa tempat tertentu dalam kode. Dalam kasus tersebut, Anda mungkin harus menyampaikan banyak informasi keadaan, tetapi keterbacaan tidak menjadi masalah besar karena hanya Anda (atau seseorang yang akan menjaga kode Anda dan harus memahami dasar-dasar modul Anda) yang harus peduli. memanggil fungsi itu.

Pertanyaan terkait yang harus Anda pertimbangkan adalah seberapa kohesifnya rutinitas itu. Sejumlah besar parameter mungkin bau yang memberitahu Anda bahwa rutin itu sendiri mencoba melakukan terlalu banyak dan karenanya kohesi dicurigai. Saya setuju bahwa sejumlah parameter yang keras dan cepat mungkin tidak mungkin tetapi saya akan menebak bahwa rutinitas kohesi yang tinggi akan menyiratkan jumlah parameter yang rendah.

97 kedengarannya hampir benar.

Kurang dan Anda kehilangan fleksibilitas.

Saya berhenti di tiga parameter sebagai aturan umum. Terlebih lagi dan inilah saatnya untuk melewatkan array parameter atau objek konfigurasi, yang juga memungkinkan parameter berikutnya ditambahkan tanpa mengubah API.

Pembatasan panjang pada daftar parameter hanyalah satu pembatasan lagi. Dan pembatasan berarti kekerasan yang diterapkan. Kedengarannya lucu, tetapi Anda bisa tanpa kekerasan bahkan saat pemrograman. Biarkan kode mendikte aturan. Jelas bahwa jika Anda memiliki banyak parameter, tubuh fungsi / metode kelas akan cukup besar untuk menggunakannya. Dan potongan kode besar biasanya dapat di refactored dan dipecah menjadi potongan yang lebih kecil. Jadi, Anda mendapatkan solusi untuk tidak memiliki banyak parameter sebagai bonus gratis, karena mereka dibagi di antara potongan kode yang lebih kecil.

Satu hal yang akan saya tunjukkan dari perspektif kinerja adalah bahwa tergantung pada bagaimana Anda mengirimkan parameter ke suatu metode, melewati banyak parameter berdasarkan nilai akan memperlambat program karena setiap parameter harus disalin dan kemudian ditempatkan di tumpukan.

Menggunakan satu kelas untuk mencakup semua parameter akan bekerja lebih baik karena satu parameter yang dilewatkan oleh referensi akan menjadi elegan dan bersih, dan lebih cepat!

Menurut saya mungkin ada kasus di mana Anda akan melebihi 4 atau beberapa nomor tetap. Hal-hal yang harus diperhatikan mungkin

1. Metode Anda terlalu banyak dan Anda perlu melakukan refactor.
2. Anda mungkin ingin mempertimbangkan untuk menggunakan koleksi atau beberapa struktur data.
3. Pikirkan kembali desain kelas Anda, mungkin beberapa hal tidak perlu diedarkan.

Dari sudut kemudahan penggunaan atau kemudahan membaca kode, saya pikir ketika Anda perlu sedikit "membungkus kata" tanda tangan metode Anda, yang seharusnya membuat Anda berhenti dan berpikir, Kecuali Anda merasa tidak berdaya dan semua upaya membuat tanda tangan lebih kecil mengarah ke tidak ada hasil. Beberapa perpustakaan yang sangat baik di masa lalu dan sekarang menggunakan lebih dari 4-5 kereta bayi.

Aturan praktis saya adalah bahwa saya harus bisa mengingat parameter cukup lama untuk melihat panggilan dan mengetahui fungsinya. Jadi jika saya tidak bisa melihat metode dan kemudian beralih ke panggilan metode dan ingat parameter mana yang melakukan apa maka ada terlalu banyak.

Bagi saya itu sama dengan sekitar 5, tapi saya tidak secerah itu. Jarak tempuh Anda mungkin beragam.

Anda bisa membuat objek dengan properti untuk menyimpan parameter dan meneruskannya jika Anda melebihi batas apa pun yang Anda tetapkan. Lihat buku Refactoring Martin Fowler dan bab tentang membuat panggilan metode lebih sederhana.

Ini sangat tergantung pada lingkungan tempat Anda bekerja. Ambil contoh javascript. Dalam javascript cara terbaik untuk mengirimkan parameter adalah menggunakan objek dengan pasangan kunci / nilai, yang dalam praktiknya berarti Anda hanya memiliki satu parameter. Dalam sistem lain, sweet spot akan berada pada tiga atau empat.

Pada akhirnya, semuanya bermuara pada selera pribadi.

Saya setuju dengan 3 tidak apa-apa, 4 terlalu banyak sebagai pedoman. Dengan lebih dari 3 parameter, Anda pasti melakukan lebih dari satu tugas. Lebih dari satu tugas harus dibagi menjadi metode terpisah.

Namun, jika saya melihat proyek terbaru yang saya kerjakan, pengecualian akan berlimpah dan sebagian besar kasus akan sulit untuk turun ke 3 parameter.

Jika saya memiliki 7-10 parameter dalam satu rutin saya melihat bundling mereka ke dalam kelas baru tetapi tidak jika kelas itu akan menjadi apa-apa selain sekelompok bidang dengan getter dan setter - kelas baru harus melakukan sesuatu selain dari nilai pengocokan dan di luar. Kalau tidak, saya lebih suka memasang dengan daftar parameter panjang.

Ini adalah fakta yang diketahui bahwa, rata-rata, orang dapat menyimpan 7 + / - 2 hal di kepala mereka sekaligus. Saya suka menggunakan prinsip itu dengan parameter. Dengan asumsi bahwa programmer semua adalah orang-orang cerdas di atas rata-rata, saya akan mengatakan semuanya 10+ terlalu banyak.

BTW, jika parameter serupa dengan cara apa pun, saya akan meletakkannya dalam vektor atau daftar daripada struct atau kelas.

Saya akan mendasarkan jawaban saya pada seberapa sering fungsi dipanggil.

Jika itu adalah fungsi init yang hanya dipanggil sekali maka biarkan dibutuhkan 10 parms atau lebih, siapa yang peduli.

Jika itu disebut banyak kali per frame maka saya cenderung membuat struktur dan hanya melewati pointer karena itu cenderung lebih cepat (dengan asumsi bahwa Anda tidak membangun kembali struct setiap waktu juga).

Menurut Jeff Bezos dari ketenaran Amazon, tidak lebih dari dapat diberi makan dengan dua pizza :