Factory-Methoden in Ruby

Was ist die raffiniertesten, die meisten Ruby-wie die Möglichkeit zu haben, einen einzigen Konstruktor return ein Objekt des entsprechenden Typs?

Um genauer zu sein, hier ein dummy-Beispiel: angenommen ich habe zwei Klassen Bike und Car die Unterklasse Vehicle. Ich möchte diese:

Vehicle.new('mountain bike')  # returns Bike.new('mountain bike')
Vehicle.new('ferrari')        # returns Car.new('ferrari')

Habe ich vorgeschlagen, eine Lösung unten, aber es nutzt allocate scheint Weg zu Umsetzung schwer. Was sind einige andere Ansätze, oder ist mir das eigentlich ok?

InformationsquelleAutor der Frage Peter | 2009-10-04

factory ruby

20

Wenn ich eine factory-Methode, die nicht genannt¹ new oder initialize ich denke mal, dass nicht wirklich eine Antwort auf die Frage "wie mache ich eine ... - Konstruktor ...", aber ich denke, das ist, wie ich es tun würde...
```
class Vehicle
  def Vehicle.factory vt
    { :Bike => Bike, :Car => Car }[vt].new
  end
end

class Bike < Vehicle
end

class Car < Vehicle
end
```
```
c = Vehicle.factory :Car
c.class.factory :Bike
```
^{1 ist. Aufruf der Methode Fabrik funktioniert wirklich gut in diesem Lehr-Beispiel, aber IRL möchten Sie vielleicht zu prüfen, @AlexChaffee's Ratschläge in den Kommentaren.}

InformationsquelleAutor der Antwort DigitalRoss
17

Ich Tat dies heute. Übersetzt in die Fahrzeuge würde es so Aussehen:
```
class Vehicle
  VEHICLES = {}

  def self.register_vehicle name
    VEHICLES[name] = self
  end

  def self.vehicle_from_name name
    VEHICLES[name].new
  end
end

class Bike < Vehicle
  register_vehicle 'mountain bike'
end

class Car < Vehicle
  register_vehicle 'ferrari'
end
```
Gefällt mir, dass die Bezeichnungen für die Klassen gehalten werden, mit den Klassen selbst, anstatt die Informationen über einen Unterklasse gespeichert, die mit der Oberklasse. Der Konstruktor wird nicht aufgerufen newaber ich sehe keinen Vorteil bei der Verwendung, insbesondere name, und es würde die Dinge schwieriger.
```
> Vehicle.vehicle_from_name 'ferrari'
=> #<Car:0x7f5780840448>
> Vehicle.vehicle_from_name 'mountain bike'
=> #<Bike:0x7f5780839198>
```
Beachten Sie, dass etwas muss sich vergewissern, dass diese Unterklassen werden geladen, bevor vehicle_from_name ausgeführt wird (vermutlich diese drei Klassen werden in unterschiedlichen source-Dateien), da sonst der Oberklasse haben keine Möglichkeit zu wissen, welche Unterklassen vorhanden ist, d.h. Sie kann nicht davon abhängen, autoload zu ziehen, diese Kategorien bei der Ausführung des Konstruktors.

Ich dies Problem gelöst, indem alle Unterklassen, z.B. ein vehicles Unterverzeichnis und fügen Sie diese am Ende der vehicle.rb:
```
require 'require_all'
require_rel 'vehicles'
```
Verwendet die require_all gem (gefunden bei https://rubygems.org/gems/require_all und https://github.com/jarmo/require_all)

InformationsquelleAutor der Antwort clacke

Angepasst hierich habe

class Vehicle
  def self.new(model_name)
    if model_name == 'mountain bike'  # etc.
      object = Bike.allocate
    else
      object = Car.allocate
    end
    object.send :initialize, model_name
    object
  end
end

class Bike < Vehicle
  def initialize(model_name)
  end
end

class Car < Vehicle
  def initialize(model_name)
  end
end

InformationsquelleAutor der Antwort Peter

Was ist ein Modul enthalten, statt der einer Oberklasse? So erhalten Sie immer noch #kind_of? zu arbeiten, und es gibt keine Standard - new ihm in die Quere.

module Vehicle
  def self.new(name)
    when 'mountain bike'
      Bike.new(name)
    when 'Ferrari'
      Car.new(name)
    ...
    end
  end
end

class Bike
  include Vehicle
end

class Car
  include Vehicle
end

InformationsquelleAutor der Antwort James A. Rosen

class VehicleFactory
  def new() 
    if (wife_allows?)
       return Motorcycle.new
    else
       return Bicycle.new
    end
  end
end

class vehicleUser 
  def doSomething(factory)
    a_vehicle = factory.new()
  end
end

und das können wir jetzt tun...

client.doSomething(Factory.new)
client.doSomething(Bicycle)    
client.doSomething(Motorcycle)

Können Sie sehen, dieses Beispiel in dem Buch Design Patterns in Ruby (Amazon link).

InformationsquelleAutor der Antwort rrichards

Können Sie reinigen die Dinge ein wenig durch die änderung Vehicle#new:

class Vehicle
  def self.new(model_name = nil)
    klass = case model_name
      when 'mountain bike' then Bike
      # and so on
      else                      Car
    end
    klass == self ? super() : klass.new(model_name)
  end
end

class Bike < Vehicle
  def self.new(model_name)
    puts "New Bike: #{model_name}"
    super
  end
end

class Car < Vehicle
  def self.new(model_name)
    puts "New Car: #{model_name || 'unknown'}"
    super
  end
end

In der letzten Zeile Vehicle.new mit der ternären Aussage ist wichtig. Ohne die Prüfung für klass == self wir stecken in einer Endlosschleife und generieren die StackError dass die anderen darauf hin, früher. Beachten Sie, dass wir haben, zu nennen super mit Klammern. Sonst würden wir uns am Ende den Aufruf mit Argumenten, die super nicht erwarten.

Und hier sind die Ergebnisse:

> Vehicle.new
New Car: unknown # from puts
# => #<Car:0x0000010106a480>

> Vehicle.new('mountain bike')
New Bike: mountain bike # from puts
# => #<Bike:0x00000101064300>

> Vehicle.new('ferrari')
New Car: ferrari # from puts
# => #<Car:0x00000101060688>

InformationsquelleAutor der Antwort Peter Wagenet

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.