Refactoring Switch Statement dan apakah ada kegunaan nyata untuk Switch Statement?

Saya membaca artikel ini dan bertanya-tanya, apakah kita menyingkirkan semua pernyataan switch dengan menggantinya dengan Kamus atau Pabrik sehingga tidak ada pernyataan beralih sama sekali dalam proyek saya.

Sesuatu tidak bertambah.

Pertanyaannya adalah, apakah pernyataan switch memiliki penggunaan nyata atau kita melanjutkan dan menggantinya dengan kamus atau metode pabrik (dalam menggunakan metode pabrik, tentu saja, akan ada penggunaan minimum pernyataan switch untuk membuat objek. menggunakan pabrik ... tapi itu saja).

Kedua switchpernyataan dan polimorfisme memiliki penggunaannya. Perhatikan bahwa opsi ketiga juga ada (dalam bahasa yang mendukung fungsi pointer / lambdas, dan fungsi tingkat tinggi): memetakan pengidentifikasi yang dipertanyakan ke fungsi handler. Ini tersedia dalam misalnya C yang bukan bahasa OO, dan C # yang *, tetapi belum (belum) di Jawa yang juga OO *.

Dalam beberapa bahasa prosedural (tidak memiliki polimorfisme atau fungsi tingkat tinggi) switch/ if-elsepernyataan adalah satu-satunya cara untuk menyelesaikan kelas masalah. Begitu banyak pengembang, setelah terbiasa dengan cara berpikir seperti ini, terus menggunakan switchbahkan dalam bahasa OO, di mana polimorfisme seringkali merupakan solusi yang lebih baik. Inilah sebabnya mengapa sering direkomendasikan untuk menghindari / switchmenolak pernyataan yang mendukung polimorfisme.

Bagaimanapun, solusi terbaik selalu tergantung pada kasus. Pertanyaannya adalah: opsi mana yang memberi Anda kode yang lebih bersih, lebih ringkas, dan lebih terpelihara dalam jangka panjang?

Pernyataan pergantian sering kali menjadi sulit, memiliki lusinan kasus, membuat pemeliharaannya sulit. Karena Anda harus menyimpannya dalam satu fungsi, fungsi itu dapat tumbuh besar. Jika demikian, Anda harus mempertimbangkan refactoring ke arah solusi berbasis peta dan / atau polimorfik.

Jika hal yang sama switchmulai muncul di banyak tempat, polimorfisme mungkin merupakan pilihan terbaik untuk menyatukan semua kasus ini dan menyederhanakan kode. Terutama jika lebih banyak kasus diharapkan akan ditambahkan di masa depan; semakin banyak tempat yang Anda butuhkan untuk memperbarui setiap kali, semakin banyak kemungkinan kesalahan. Namun, sering kali penangan kasus individu sangat sederhana, atau ada begitu banyak dari mereka, atau mereka sangat terkait, sehingga refactoring mereka ke dalam hirarki kelas polimorfik penuh adalah berlebihan, atau menghasilkan banyak kode duplikat dan / atau kusut, sulit untuk mempertahankan hierarki kelas. Dalam hal ini, mungkin lebih mudah menggunakan fungsi / lambdas saja (jika bahasa Anda memungkinkan Anda).

Namun, jika Anda memiliki switchdi satu tempat, dengan hanya beberapa kasus melakukan sesuatu yang sederhana, itu mungkin merupakan solusi terbaik untuk membiarkannya seperti itu.

* ^{Saya menggunakan istilah "OO" secara longgar di sini; Saya tidak tertarik pada perdebatan konseptual tentang apa yang "nyata" atau "murni" OO.}

Di sinilah saya kembali menjadi dinosaurus ...

Ganti pernyataan tidak buruk dalam diri mereka sendiri, penggunaannya yang membuat mereka yang dipermasalahkan.

Yang paling jelas adalah pernyataan pergantian "sama" berulang-ulang melalui kode Anda yang buruk (pernah ada, melakukan itu, akan melakukan segala upaya untuk tidak lagi) - dan ini kasus terakhir yang mungkin dapat Anda tangani dengan menggunakan polimorfisme. Biasanya ada sesuatu yang cukup mengerikan tentang kasus bersarang (saya dulu memiliki monster absolut - tidak sepenuhnya yakin bagaimana saya menghadapinya sekarang selain "lebih baik").

Kamus sebagai sakelar Saya merasa lebih menantang - pada dasarnya ya jika sakelar Anda mencakup 100% kasing, tetapi jika Anda ingin memiliki bawaan atau tidak ada kasing, sakelar ini mulai sedikit lebih menarik.

Saya pikir ini pertanyaan menghindari pengulangan dan memastikan kita menyusun grafik objek kita di tempat yang tepat.

Tetapi ada juga argumen pemahaman (pemeliharaan) dan ini memotong kedua cara - setelah Anda memahami bagaimana semuanya bekerja (pola dan aplikasi di mana penerapannya) mudah ... tetapi jika Anda datang ke satu baris kode di mana Anda harus menambahkan sesuatu yang baru Anda kemudian harus melompati semua tempat untuk mencari tahu apa yang perlu Anda tambahkan / ubah.

Untuk semua itu, lingkungan pengembangan kami mampu secara besar-besaran. Saya masih merasa perlu memahami kode (seolah-olah) dicetak di atas kertas - dapatkah Anda mengikuti kode dengan jari Anda? Saya menerima bahwa sebenarnya tidak, dengan banyak latihan yang baik hari ini Anda tidak dapat dan karena alasan yang baik tetapi itu berarti untuk mempercepat dengan kode lebih sulit untuk memulai (atau mungkin saya hanya tua ...)

Switch-statement vs subtype-polymorphism adalah masalah lama dan sering disebut dalam komunitas FP dalam diskusi tentang Masalah Ekspresi .

Pada dasarnya, kami memiliki tipe (kelas) dan fungsi (metode). Bagaimana cara kita membuat kode hal-hal sehingga mudah untuk menambahkan tipe baru atau metode baru yang terakhir?

Jika Anda memprogram dalam gaya OO, sulit untuk menambahkan metode baru (karena itu berarti refactoring semua kelas yang ada), tetapi sangat mudah untuk menambahkan kelas baru yang menggunakan metode yang sama seperti sebelumnya.

Di sisi lain, jika Anda menggunakan pernyataan switch (atau yang setara dengan OO-nya, Pola Observer) maka sangat mudah untuk menambahkan fungsi-fungsi baru tetapi sulit untuk menambahkan kasus / kelas baru.

Tidaklah mudah untuk memiliki ekstensibilitas yang baik di kedua arah, jadi saat menulis kode Anda, tentukan apakah akan menggunakan polimorfisme atau beralih pernyataan tergantung pada arah mana Anda lebih cenderung memperluasnya.

kita menyingkirkan semua pernyataan switch dengan menggantinya dengan Kamus atau Pabrik sehingga tidak ada pernyataan beralih sama sekali di proyek saya.

Tidak. Mutlak seperti itu jarang merupakan ide yang bagus.

Banyak tempat, pengiriman kamus / pencarian / pabrik / polimorfik akan memberikan desain yang lebih baik daripada pernyataan beralih tetapi Anda masih harus mengisi kamus. Dalam kasus-kasus tertentu, itu akan mengaburkan apa yang sebenarnya terjadi dan hanya memiliki pernyataan peralihan yang sejalan lebih mudah dibaca dan dikelola.

Melihat bagaimana ini bahasa-agnostik, kode fall-through paling baik digunakan dengan switchpernyataan:

switch(something) {
   case 1:
      foo();
   case 2:
      bar();
      baz();
      break;

   case 3:
      bang();
   default:
      bizzap();
      break;
}

Setara dengan if, dengan kasus default yang sangat canggung. Dan perlu diingat bahwa semakin banyak kegagalan yang terjadi, semakin lama daftar kondisi akan didapat:

if (1 == something) {
   foo();
}
if (1 == something || 2 == something) {
   bar();
   baz();
}
if (3 == something) {
   bang();
}
if (1 != something && 2 != something) {
   bizzap();
}

(Namun, mengingat apa yang dikatakan beberapa jawaban lain, saya merasa saya telah melewatkan inti pertanyaan ...)

Beralih pernyataan sebagai diferensiasi kasus memang memiliki kegunaan nyata. Bahasa pemrograman fungsional menggunakan sesuatu yang disebut pencocokan pola yang memungkinkan Anda untuk mendefinisikan fungsi secara berbeda tergantung pada input. Namun dalam bahasa berorientasi objek tujuan yang sama dapat dicapai lebih elegan dengan menggunakan polimorfisme. Anda cukup memanggil metode dan tergantung pada jenis objek yang sebenarnya, implementasi metode yang sesuai akan dieksekusi. Ini adalah alasan di balik gagasan itu, bahwa pernyataan switch adalah bau kode. Namun, bahkan dalam bahasa OO, Anda mungkin menemukan mereka berguna untuk menerapkan pola pabrik abstrak.

tl; dr - mereka berguna, tetapi cukup sering Anda dapat melakukan lebih baik.