Ruby: Selbst erweitern

In Ruby verstehe ich die Grundidee von extend. Was passiert jedoch in diesem Codesegment? Was macht konkret extend? Ist es nur eine bequeme Möglichkeit, die Instanzmethoden in Klassenmethoden umzuwandeln? Warum sollten Sie dies so tun, anstatt von Anfang an Klassenmethoden anzugeben?

module Rake
  include Test::Unit::Assertions

  def run_tests # etc.
  end

  # what does the next line do?
  extend self
end

Es ist eine bequeme Möglichkeit, Instanzmethoden in Klassenmethoden umzuwandeln. Sie können es aber auch als effizienteren Singleton verwenden .

In einem Modul ist self die Modulklasse selbst. So zum Beispiel

puts self

wird Rake so zurückgeben,

extend self

Grundsätzlich stehen ihm die in Rake definierten Instanzmethoden zur Verfügung, damit Sie dies tun können

Rake.run_tests

Für mich ist es immer hilft , zu denken , extendwieinclude innerhalb der Singleton-Klasse (auch als Meta oder Eigenklasse bekannt) zu betrachten.

Sie wissen wahrscheinlich, dass in der Singleton-Klasse definierte Methoden im Grunde Klassenmethoden sind:

module A
  class << self
    def x
      puts 'x'
    end
  end
end

A.x #=> 'x'

Jetzt, da wir das wissen, extendwerden includedie Methoden im Modul innerhalb der Singleton-Klasse und damit als Klassenmethoden verfügbar gemacht:

module A
  class << self
    include A

    def x
      puts 'x'
    end
  end

  def y
    puts 'y'
  end
end

A.x #=> 'x'
A.y #=> 'y'

Um Link Rot zu vermeiden, wird der von user83510 verlinkte Blog-Beitrag von Chris Wanstrath unten (mit seiner Erlaubnis) erneut veröffentlicht. Trotzdem ist nichts besser als ein Original. Verwenden Sie seinen Link, solange er funktioniert.

→ Singletons singen 18. November 2008 Es gibt Dinge, die ich einfach nicht verstehe. David Bowie zum Beispiel. Oder die südliche Hemisphäre. Aber nichts verwirrt mich so sehr wie Rubys Singleton. Weil es wirklich völlig unnötig ist.

Folgendes sollen Sie mit Ihrem Code tun:

require 'net/http'

# first you setup your singleton
class Cheat
  include Singleton

  def initialize
    @host = 'http://cheat.errtheblog.com/'
    @http = Net::HTTP.start(URI.parse(@host).host)
  end


  def sheet(name)
    @http.get("/s/#{name}").body
  end
end

# then you use it
Cheat.instance.sheet 'migrations'
Cheat.instance.sheet 'yahoo_ceo'

Aber das ist verrückt. Kämpfe gegen die Macht.

require 'net/http'

# here's how we roll
module Cheat
  extend self

  def host
    @host ||= 'http://cheat.errtheblog.com/'
  end

  def http
    @http ||= Net::HTTP.start(URI.parse(host).host)
  end

  def sheet(name)
    http.get("/s/#{name}").body
  end
end

# then you use it
Cheat.sheet 'migrations'
Cheat.sheet 'singletons'

Warum nicht? Die API ist prägnanter, der Code ist einfacher zu testen, zu verspotten und zu stubben, und es ist immer noch kinderleicht, ihn bei Bedarf in eine richtige Klasse zu konvertieren.

((Copyright sollte zehn Chris Wanstrath)

extend selfEnthält alle vorhandenen Instanzmethoden als Modulmethoden. Dies ist gleichbedeutend mit sagen extend Rake. Ist auch Rakeein Objekt der Klasse Module.

Ein anderer Weg, um ein gleichwertiges Verhalten zu erreichen, ist:

module Rake
  include Test::Unit::Assertions

  def run_tests # etc.
  end

end 

Rake.extend(Rake)

Dies kann verwendet werden, um eigenständige Module mit privaten Methoden zu definieren.