Kapan harus menggunakan kelas bersarang dan kelas bersarang dalam modul?

Saya cukup akrab dengan kapan harus menggunakan subclass dan modul, tetapi baru-baru ini saya telah melihat kelas bersarang seperti ini:

class Foo
  class Bar
    # do some useful things
  end
end

Serta kelas yang bersarang dalam modul seperti:

module Baz
  class Quux
    # more code
  end
end

Dokumentasi dan artikel jarang atau saya tidak dididik pada subjek yang cukup untuk meraba-raba istilah pencarian yang tepat, tetapi saya sepertinya tidak dapat menemukan banyak informasi tentang topik tersebut.

Bisakah seseorang memberikan contoh atau tautan ke posting tentang mengapa / kapan teknik itu akan digunakan?

Bahasa OOP lainnya memiliki kelas dalam yang tidak dapat dipakai tanpa terikat dengan kelas tingkat atas. Misalnya, di Jawa,

class Car {
    class Wheel { }
}

hanya metode di Carkelas yang dapat membuat Wheels.

Ruby tidak memiliki perilaku itu.

Di Ruby,

class Car
  class Wheel
  end
end

berbeda dari

class Car
end

class Wheel
end

hanya dalam nama kelas Wheelvs Car::Wheel. Perbedaan nama ini dapat membuat eksplisit untuk programmer bahwa Car::Wheelkelas hanya dapat mewakili roda mobil, sebagai lawan dari roda umum. Definisi kelas bersarang di Ruby adalah masalah preferensi, tetapi melayani tujuan dalam arti bahwa itu lebih kuat menegakkan kontrak antara dua kelas dan dengan demikian menyampaikan lebih banyak informasi tentang mereka dan penggunaannya.

Tetapi bagi interpreter Ruby, itu hanya perbedaan nama.

Sedangkan untuk pengamatan kedua Anda, kelas yang bersarang di dalam modul umumnya digunakan untuk namespace kelas. Misalnya:

module ActiveRecord
  class Base
  end
end

berbeda dari

module ActionMailer
  class Base
  end
end

Meskipun ini bukan satu-satunya penggunaan kelas yang bersarang di dalam modul, pada umumnya yang paling umum.

Di Ruby, mendefinisikan kelas bertingkat mirip dengan mendefinisikan kelas dalam sebuah modul. Itu tidak benar-benar memaksa hubungan antara kelas, itu hanya membuat namespace untuk konstanta. (Nama Kelas dan Modul adalah konstanta.)

Jawaban yang diterima tidak benar tentang apa pun. ¹ Dalam contoh di bawah ini saya membuat turunan dari kelas tertutup secara leksikal tanpa turunan dari kelas penutup yang pernah ada.

class A; class B; end; end
A::B.new

Keuntungannya sama dengan yang ada pada modul: enkapsulasi, pengelompokan kode yang hanya digunakan di satu tempat, dan menempatkan kode lebih dekat ke tempat digunakannya. Proyek besar mungkin memiliki satu modul luar yang terjadi berulang-ulang di setiap file sumber dan berisi banyak definisi kelas. Ketika berbagai kerangka kerja dan kode perpustakaan semua melakukan ini, maka mereka hanya berkontribusi satu nama masing-masing ke tingkat atas, mengurangi kemungkinan konflik. Prosa, tentu saja, tapi itu sebabnya mereka digunakan.

Menggunakan kelas alih-alih modul untuk mendefinisikan namespace luar mungkin masuk akal dalam program atau skrip satu file, atau jika Anda sudah menggunakan kelas tingkat atas untuk sesuatu, atau jika Anda benar-benar akan menambahkan kode untuk menghubungkan kelas bersama-sama dalam gaya kelas batin sejati . Ruby tidak memiliki kelas dalam tetapi tidak ada yang menghentikan Anda untuk membuat perilaku yang sama dalam kode. Merujuk objek luar dari yang dalam masih akan membutuhkan titik-titik dari instance objek luar tetapi kelas bersarang akan menyarankan bahwa ini adalah apa yang mungkin Anda lakukan. Program termodulasi dengan hati-hati mungkin selalu membuat kelas-kelas yang melampirkan terlebih dahulu, dan mereka mungkin cukup didekomposisi dengan kelas bersarang atau batin. Anda tidak dapat memanggil newmodul.

Anda dapat menggunakan pola umum bahkan untuk skrip, di mana namespace tidak terlalu dibutuhkan, hanya untuk bersenang-senang dan berlatih ...

#!/usr/bin/env ruby

class A
  class Realwork_A
    ...
  end
  class Realwork_B
    ...
  end

  def run
    ...
  end

  self
end.new.run

Anda mungkin ingin menggunakan ini untuk mengelompokkan kelas Anda ke dalam modul. Semacam hal namespace.

misalnya permata Twitter menggunakan ruang nama untuk mencapai ini:

Twitter::Client.new

Twitter::Search.new

Jadi keduanya Clientdan Searchkelas hidup di bawah Twittermodul.

Jika Anda ingin memeriksa sumbernya, kode untuk kedua kelas dapat ditemukan di sini dan di sini .

Semoga ini membantu!

Ada perbedaan lain antara kelas bersarang dan modul bersarang di Ruby sebelum 2,5 yang jawaban lain gagal untuk menutupi yang saya rasa harus disebutkan di sini. Ini adalah proses pencarian.

Singkatnya: karena pencarian konstan tingkat atas di Ruby sebelum 2.5, Ruby mungkin akhirnya mencari kelas bersarang Anda di tempat yang salah ( Objectkhususnya) jika Anda menggunakan kelas bersarang.

Di Ruby sebelum 2.5:
Struktur kelas bersarang: Misalkan Anda memiliki kelas X, dengan kelas bertingkat Y, atau X::Y. Dan kemudian Anda memiliki kelas tingkat atas bernama juga Y. Jika X::Ytidak dimuat, maka hal berikut terjadi ketika Anda menelepon X::Y:

Setelah tidak ditemukan YdiX , Ruby akan mencoba untuk mencarinya di nenek moyang X. SejakXadalah kelas dan bukan modul, ia memiliki leluhur, di antaranya adalah [Object, Kernel, BasicObject]. Jadi, ia mencoba mencari , Ydi Objectmana ia berhasil menemukannya.

Namun itu adalah level atas Ydan bukan X::Y. Anda akan mendapatkan peringatan ini:

warning: toplevel constant Y referenced by X::Y

Struktur modul bersarang: Misalkan pada contoh sebelumnya Xadalah modul dan bukan kelas.

Modul hanya memiliki dirinya sebagai leluhur: X.ancestorsakan menghasilkan [X].

Dalam hal ini, Ruby tidak akan dapat mencari Ydi salah satu leluhur Xdan akan melempar NameError. Rails (atau kerangka kerja lainnya dengan autoloading) akan mencoba memuat X::Ysetelah itu.

Lihat artikel ini untuk informasi lebih lanjut: https://blog.jetbrains.com/ruby/2017/03/why-you-should-not-use-a--class-as-a-namespace-in-rails-applications/

In Ruby 2.5:
Pencarian konstan tingkat atas dihapus.
Anda dapat menggunakan kelas bersarang tanpa takut menemukan bug ini.

Selain jawaban sebelumnya: Modul di Ruby adalah kelas

$ irb
> module Some end
=> nil
> Some.class
=> Module
> Module.superclass
=> Object