Wie rufe ich eine Methode, die ein hash-Wert?

Erste von allen, Sie werden nicht setzen ein lambda in der hash. Sie setzen die Ergebnis des Aufrufs a() im aktuellen Kontext.

Angesichts dieser Informationen, überlegen, was der code in der Klasse bedeutet. Der Kontext der definition einer Klasse ist die Klasse. So definieren Sie eine Instanz-Methode aufgerufen a, und ordnen Sie eine Klasse-Instanz-variable ein hash enthält das Ergebnis des Aufrufs a im aktuellen Kontext. Der aktuelle Kontext ist die Klasse A, und Klasse A hat auch keine Methode einer Klasse aufgerufen a, so dass Sie versuchen, das Ergebnis einer nicht vorhandenen Methode gibt. Dann in der Instanz-Methode b Sie versuchen, Zugriff auf eine Instanz-variable namens @a - aber gibt es nicht. Die @a in der Klasse definiert Kontext gehört zu der Klasse selbst, nicht eine bestimmte Instanz.

Also zunächst einmal, wenn Sie möchten, eine lambda, die Sie brauchen, um einen lambda-Ausdruck. Zweitens müssen Sie klar sein über den Unterschied zwischen einer Klasse und einer Instanz der Klasse.

Wenn Sie möchten, machen Sie eine Liste von Methodennamen aufgerufen werden, auf bestimmte Bedingungen, kannst du es so machen:

class A
  def self.conditions() { 0 => :a } end

  def a
    puts "Hello!"
  end

  def b(arg)
    send self.class.conditions[arg]
  end
end

Dieser legt die Bedingungen fest, hash als Methode der Klasse (so dass es leichten Zugang), und der hash enthält lediglich den Namen der Methode zu nennen, eher als einen lambda-Ausdruck oder ähnliches. Also, wenn Sie rufen b(0) es sends selbst die Nachricht enthielt in A. Bedingungen[0], die a.

InformationsquelleAutor Chuck

Wenn Sie wirklich wollen einfach nur ziemlich diese Art der Sache,
warum nicht wickeln Sie alle Ihre Methoden in einer Klasse etwa so:

# a container to store all your methods you want to use a hash to access
class MethodHash
  alias [] send
  def one
    puts "I'm one"
  end
  def two
    puts "I'm two"
  end
end

x = MethodHash.new
x[:one] # prints "I'm one"
x.two # prints "I'm one"

oder, um dein Beispiel:

# a general purpose object that transforms a hash into calls on methods of some given object
class DelegateHash
  def initialize(target, method_hash)
    @target = target
    @method_hash = method_hash.dup
  end
  def [](k)
    @target.send(@method_hash[k])
  end
end

class A
  def initialize
    @a = DelegateHash.new(self, { 0 => :a })
  end
  def a()
    puts "hello world"
  end
  def b()
    @a[0]
  end
end

x = A.new
x.a #=> prints "hello world"
x.b #=> prints "hello world"

Einen anderen grundlegenden Fehler, die Sie gemacht ist, dass Sie initialisiert @a außerhalb einer Instanz-Methode -
nur bare Innenseite der definition von A. Dies ist eine riesige no-no, weil es einfach nicht funktioniert.
Denken Sie daran, in ruby ist alles ein Objekt, einschließlich der Klassen, und die @ Präfix bedeutet, dass die Instanz
variable, jedes Objekt, ist derzeit selbst. Innerhalb einer Instanz-Methode, Definitionen, self ist eine Instanz
von der Klasse. Aber außerhalb der, dass, nur innerhalb der Klassendefinition self ist die Klasse-Objekt - so ist Sie definiert
eine Instanz-variable namens @a für die Objekt-Klasse A, die keine Instanzen von A kann man direkt.

Ruby hat einen Grund für dieses Verhalten (Klasse-Instanz-Variablen können praktisch, wenn Sie wirklich wissen, was
du tust), aber dies ist eine fortgeschrittene Technik.

Kurz, nur initialisieren von Instanzvariablen in der initialize Methode.

InformationsquelleAutor rampion

Ich bin ziemlich neu mit callbacks in Ruby und dies ist, wie ich erklärte es mir anhand eines Beispiels:

require 'logger'
log = Logger.new('/var/tmp/log.out')

def callit(severity, msg, myproc)
  myproc.call(sev, msg)
end

lookup_severity = {}
lookup_severity['info'] = Proc.new { |x| log.info(x) }
lookup_severity['debug'] = Proc.new { |x| log.debug(x) }

logit = Proc.new { |x,y| lookup_sev[x].call(y) }

callit('info', "check4", logit)
callit('debug', "check5", logit)

InformationsquelleAutor Saurabh Hirani