Überschreibungsmethode durch eine andere im Modul definierte Methode

Möchte ich definieren eine Instanz-Methode Date#next die gibt den nächsten Tag. Also machte ich einen DateExtension Modul, so wie dieses:

module DateExtension
  def next(symb=:day)
    dt = DateTime.now
    {:day   => Date.new(dt.year, dt.month, dt.day + 1),
     :week  => Date.new(dt.year, dt.month, dt.day + 7),
     :month => Date.new(dt.year, dt.month + 1, dt.day),
     :year  => Date.new(dt.year + 1, dt.month, dt.day)}[symb]
  end
end

Mit:

class Date
  include DateExtension
end

Aufruf der Methode d.next(:week) macht Ruby wirft einen Fehler ArgumentError: wrong number of arguments (1 for 0).
Wie kann ich den Standardwert überschreiben next Methode von Date Klasse mit der man erklärte, im DateExtension Modul?

InformationsquelleAutor der Frage resilva87 | 2011-05-10

99

In Ruby 2.0 und höher können Sie Module#prepend:
```
class Date
  prepend DateExtension
end
```
Ursprüngliche Antwort für ältere Ruby-Versionen ist unten.

Das problem mit include (wie gezeigt in das folgende Diagramm) ist, dass die Methoden einer Klasse können nicht überschrieben werden, indem Module, die in dieser Klasse (Lösungen Folgen Sie dem Diagramm):

Lösungen
1. Unterklasse Datum nur für diese eine Methode:
```
irb(main):001:0> require 'date'; module Foo; def next(a=:hi); a; end; end
#=> nil
irb(main):002:0> class MyDate < Date; include Foo; end
#=> MyDate
irb(main):003:0> MyDate.today.next(:world)
#=> :world
```
2. Verlängern nur die Instanzen, die Sie brauchen, mit Ihrem eigenen Methode:
```
irb(main):001:0> require 'date'; module Foo; def next(a=:hi); a; end; end
#=> nil
irb(main):002:0> d = Date.today; d.extend(Foo); d.next(:world)
#=> :world
```
3. Wenn Ihr Modul, ausführen einer grob hacken und erreichen innerhalb der Klasse und zerstören das alte 'weiter so, dein wird genannt:
```
irb(main):001:0> require 'date'
#=> true
irb(main):002:0> module Foo
irb(main):003:1>   def self.included(klass)
irb(main):004:2>     klass.class_eval do
irb(main):005:3*       remove_method :next
irb(main):006:3>     end
irb(main):007:2>   end
irb(main):008:1>   def next(a=:hi); a; end
irb(main):009:1> end
#=> nil
irb(main):010:0> class Date; include Foo; end
#=> Date
irb(main):011:0> Date.today.next(:world)
#=> :world
```
  Diese Methode ist weit mehr invasiv als nur inklusive ein Modul, aber der einzige Weg (der die Techniken gezeigt bisher) so zu machen, dass neue Date-Instanzen zurückgegeben werden, die von system-Methoden werden automatisch verwenden Methoden aus der eigenen Modul.
4. Aber wenn du gehst zu tun, Sie könnte genauso gut überspringen Sie das Modul zusammen und gehen Sie gerade zu monkeypatch land:
```
irb(main):001:0> require 'date'
#=> true
irb(main):002:0> class Date
irb(main):003:1>   alias_method :_real_next, :next
irb(main):004:1>   def next(a=:hi); a; end
irb(main):005:1> end
#=> nil
irb(main):006:0> Date.today.next(:world)
#=> :world
```
5. Wenn Sie wirklich brauchen diese Funktion in Ihrer eigenen Umgebung, beachten Sie, dass die Voranstellen Bibliothek von banisterfiend können, geben Ihnen die Möglichkeit, Ursache-lookup auftreten, in einem Modul vor der Klasse, in die es gemischt wird.
  - Beachten Sie, dass Module#prepend sieht kommen in Ruby 2.0.
InformationsquelleAutor der Antwort Phrogz
5

Den next Methode für Date definiert wird, in der Date Klasse und Methoden in einer Klasse definiert, Vorrang vor denen definiert in einem Modul enthalten. Also, wenn Sie dies tun:
```
class Date
  include DateExtension
end
```
Sind Sie ziehen in Ihrer version von next aber die next definiert in Date immer noch Vorrang. Sie müssen Ihre next rechts in Date:
```
class Date
  def next(symb=:day)
    dt = DateTime.now
      {:day   => Date.new(dt.year, dt.month, dt.day + 1),
       :week  => Date.new(dt.year, dt.month, dt.day + 7),
       :month => Date.new(dt.year, dt.month + 1, dt.day),
       :year  => Date.new(dt.year + 1, dt.month, dt.day)}[symb]
    end
end
```
Aus der die Programmierung Ruby Kapitel Klassen und Objekte:

Wenn eine Klasse enthält ein Modul, das Modul-Instanz-Methoden verfügbar, die als Instanz-Methoden der Klasse. Es ist fast so, als ob das Modul wird eine Superklasse der Klasse, der es verwendet. Nicht überraschend ist, dass die über, wie es funktioniert. Wenn Sie ein Modul umfassen, Ruby schafft einen anonymen proxy-Klasse, die Verweise, die module und Einsätze, die der proxy als die direkte Oberklasse der Klasse, die habe die inklusive.

InformationsquelleAutor der Antwort mu is too short

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Lösungen