Quando utilizzare le classi nidificate e le classi nidificate nei moduli?

Conosco abbastanza bene quando usare sottoclassi e moduli, ma più recentemente ho visto classi nidificate come questa:

class Foo
  class Bar
    # do some useful things
  end
end

Oltre alle classi nidificate in moduli come questo:

module Baz
  class Quux
    # more code
  end
end

O la documentazione e gli articoli sono scarsi o non sono abbastanza istruito sull'argomento da tentare i giusti termini di ricerca, ma non riesco a trovare molte informazioni sull'argomento.

Qualcuno potrebbe fornire esempi o collegamenti a post sul perché / quando tali tecniche dovrebbero essere utilizzate?

Altri linguaggi OOP hanno classi interne che non possono essere istanziate senza essere legate a una classe di livello superiore. Ad esempio, in Java,

class Car {
    class Wheel { }
}

solo i metodi nella Carclasse possono creare Wheels.

Ruby non ha questo comportamento.

In Ruby,

class Car
  class Wheel
  end
end

si differenzia da

class Car
end

class Wheel
end

solo in nome della classe Wheelcontro Car::Wheel. Questa differenza di nome può rendere esplicito ai programmatori che la Car::Wheelclasse può rappresentare solo una ruota di automobile, al contrario di una ruota generale. La nidificazione delle definizioni delle classi in Ruby è una questione di preferenza, ma ha uno scopo nel senso che impone più fortemente un contratto tra le due classi e nel farlo trasmette più informazioni su di loro e sui loro usi.

Ma per l'interprete Ruby, c'è solo una differenza nel nome.

Per quanto riguarda la tua seconda osservazione, le classi nidificate all'interno dei moduli vengono generalmente utilizzate per lo spazio dei nomi delle classi. Per esempio:

module ActiveRecord
  class Base
  end
end

si differenzia da

module ActionMailer
  class Base
  end
end

Sebbene questo non sia l'unico uso delle classi nidificate all'interno dei moduli, è generalmente il più comune.

In Ruby, la definizione di una classe nidificata è simile alla definizione di una classe in un modulo. In realtà non forza un'associazione tra le classi, crea semplicemente uno spazio dei nomi per le costanti. (I nomi di classe e modulo sono costanti.)

La risposta accettata non era corretta su nulla. ¹ Nell'esempio seguente creo un'istanza della classe racchiusa in modo lessicale senza mai esistere un'istanza della classe acclusa.

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

I vantaggi sono gli stessi di quelli dei moduli: incapsulamento, raggruppamento del codice usato in un solo posto e posizionamento del codice più vicino al luogo in cui viene utilizzato. Un progetto di grandi dimensioni potrebbe avere un modulo esterno che si verifica ripetutamente in ogni file di origine e contiene molte definizioni di classe. Quando i vari framework e codici di libreria lo fanno tutti, contribuiscono con un solo nome ciascuno al livello più alto, riducendo la possibilità di conflitti. Prosaico, certo, ma è per questo che vengono usati.

L'utilizzo di una classe anziché di un modulo per definire lo spazio dei nomi esterno potrebbe avere senso in un programma o script a un file, oppure se si utilizza già la classe di livello superiore per qualcosa o se si intende effettivamente aggiungere codice per collegare le classi insieme nel vero stile di classe interiore . Ruby non ha classi interne ma nulla ti impedisce di creare lo stesso comportamento nel codice. Fare riferimento agli oggetti esterni da quelli interni richiederà comunque il puntamento dall'istanza dell'oggetto esterno, ma annidare le classi suggerirà che questo è ciò che potresti fare. Un programma attentamente modulare potrebbe sempre creare prima le classi che la racchiudono e potrebbero ragionevolmente essere scomposte con classi nidificate o interne. Non puoi chiamare newun modulo.

Puoi usare il modello generale anche per gli script, dove lo spazio dei nomi non è terribilmente necessario, solo per divertimento e pratica ...

#!/usr/bin/env ruby

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

  def run
    ...
  end

  self
end.new.run

Probabilmente vuoi usarlo per raggruppare le tue classi in un modulo. Sorta di una cosa dello spazio dei nomi.

ad esempio la gemma di Twitter utilizza gli spazi dei nomi per raggiungere questo obiettivo:

Twitter::Client.new

Twitter::Search.new

Così sia Cliente Searchclassi di vivere sotto il Twittermodulo.

Se vuoi controllare le fonti, il codice per entrambe le classi può essere trovato qui e qui .

Spero che questo ti aiuti!

C'è ancora un'altra differenza tra le classi nidificate e i moduli nidificati in Ruby prima della 2.5 che altre risposte non sono riuscite a coprire che ritengo debbano essere menzionate qui. È il processo di ricerca.

In breve: a causa della costante ricerca di livello superiore in Ruby precedente alla 2.5, Ruby potrebbe finire per cercare la classe nidificata nel posto sbagliato ( Objectin particolare) se si utilizzano classi nidificate.

In Ruby prima della 2.5:
Struttura della classe nidificata: Supponiamo di avere una classe X, con classe nidificata Y, oppure X::Y. E poi hai anche una classe di livello superiore chiamata Y. Se X::Ynon è caricato, seguendo poi accade quando si chiama X::Y:

Non avendo trovato Yin XRuby cercherà di cercarlo nella antenati X. DaXè una classe e non un modulo, ha antenati, tra i quali lo sono [Object, Kernel, BasicObject]. Quindi, tenta di cercare Yin Object, dove trova con successo.

Eppure è il livello più alto Ye non X::Y. Riceverai questo avviso:

warning: toplevel constant Y referenced by X::Y

Struttura del modulo nidificato: supponiamo che nell'esempio precedente Xsia un modulo e non una classe.

Un modulo ha solo se stesso come antenato: X.ancestorsprodurrebbe [X].

In questo caso, Ruby non sarà in grado di cercare Yin uno degli antenati di Xe lancerà a NameError. Le rotaie (o qualsiasi altro framework con caricamento automatico) proveranno a caricarsi X::Ysuccessivamente.

Vedi questo articolo per maggiori informazioni: https://blog.jetbrains.com/ruby/2017/03/why-you-should-not-use-a-class-as-a-namespace-in-rails-applications/

In Ruby 2.5:
Ricerca costante di livello superiore rimossa.
È possibile utilizzare le classi nidificate senza timore di riscontrare questo errore.

Oltre alle risposte precedenti: il modulo in Ruby è una classe

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