Übergeben einer Methode als Parameter in Ruby

Ich versuche ein bisschen mit Ruby herumzuspielen. Daher versuche ich, die Algorithmen (in Python angegeben) aus dem Buch "Programming Collective Intelligence" Ruby zu implementieren.

In Kapitel 8 übergibt der Autor eine Methode a als Parameter. Dies scheint in Python zu funktionieren, aber nicht in Ruby.

Ich habe hier die Methode

def gaussian(dist, sigma=10.0)
  foo
end

und möchte dies mit einer anderen Methode aufrufen

def weightedknn(data, vec1, k = 5, weightf = gaussian)
  foo
  weight = weightf(dist)
  foo
end

Ich habe nur einen Fehler

ArgumentError: wrong number of arguments (0 for 1)

Sie möchten ein Proc-Objekt:

gaussian = Proc.new do |dist, *args|
  sigma = args.first || 10.0
  ...
end

def weightedknn(data, vec1, k = 5, weightf = gaussian)
  ...
  weight = weightf.call(dist)
  ...
end

Beachten Sie nur, dass Sie in einer solchen Blockdeklaration kein Standardargument festlegen können. Sie müssen also einen Splat verwenden und den Standard im Proc-Code selbst einrichten.

Abhängig von Ihrem Umfang ist es möglicherweise einfacher, stattdessen einen Methodennamen zu übergeben.

def weightedknn(data, vec1, k = 5, weightf = :gaussian)
  ...
  weight = self.send(weightf)
  ...
end

In diesem Fall rufen Sie nur eine Methode auf, die für ein Objekt definiert ist, anstatt einen vollständigen Codeabschnitt zu übergeben. Je nachdem , wie Sie diese Struktur , die Sie brauchen ersetzen kann self.sendmitobject_that_has_the_these_math_methods.send

Zu guter Letzt können Sie einen Block an die Methode hängen.

def weightedknn(data, vec1, k = 5)
  ...
  weight = 
    if block_given?
      yield(dist)
    else
      gaussian.call(dist)
    end
  end
  ...
end

weightedknn(foo, bar) do |dist|
  # square the dist
  dist * dist
end

Es hört sich jedoch so an, als ob Sie hier mehr wiederverwendbare Codestücke wünschen.

Die Kommentare zu Blöcken und Prozessen sind insofern korrekt, als sie in Ruby üblicher sind. Sie können jedoch eine Methode übergeben, wenn Sie möchten. Sie rufen methodauf, um die Methode abzurufen und .callaufzurufen:

def weightedknn( data, vec1, k = 5, weightf = method(:gaussian) )
  ...
  weight = weightf.call( dist )
  ...
end

Sie können eine Methode als Parameter mit method(:function)way übergeben. Unten ist ein sehr einfaches Beispiel:

def double (a)
  return a * 2 
Ende
=> Null

def method_with_function_as_param (Rückruf, Nummer) 
  callback.call (Nummer) 
Ende 
=> Null

method_with_function_as_param (method (: double), 10) 
=> 20

Der normale Ruby-Weg, dies zu tun, ist die Verwendung eines Blocks.

Es wäre also so etwas wie:

def weightedknn( data, vec1, k = 5 )
  foo
  weight = yield( dist )
  foo
end

Und verwendet wie:

weightenknn( data, vec1 ) { |dist| gaussian( dist ) }

Dieses Muster wird in Ruby häufig verwendet.

Sie können den &Operator für die MethodInstanz Ihrer Methode verwenden, um die Methode in einen Block zu konvertieren .

Beispiel:

def foo(arg)
  p arg
end

def bar(&block)
  p 'bar'
  block.call('foo')
end

bar(&method(:foo))

Weitere Informationen finden Sie unter http://weblog.raganwald.com/2008/06/what-does-do-when-used-as-unary.html

Sie müssen die Methode "call" des Funktionsobjekts aufrufen:

weight = weightf.call( dist )

EDIT: Wie in den Kommentaren erläutert, ist dieser Ansatz falsch. Es würde funktionieren, wenn Sie Procs anstelle normaler Funktionen verwenden.

Ich würde empfehlen, kaufmännisches Und zu verwenden, um Zugriff auf benannte Blöcke innerhalb einer Funktion zu erhalten. Wenn Sie den Empfehlungen in diesem Artikel folgen, können Sie so etwas schreiben (dies ist ein echter Ausschnitt aus meinem Arbeitsprogramm):

  # Returns a valid hash for html form select element, combined of all entities
  # for the given +model+, where only id and name attributes are taken as
  # values and keys correspondingly. Provide block returning boolean if you
  # need to select only specific entities.
  #
  # * *Args*    :
  #   - +model+ -> ORM interface for specific entities'
  #   - +&cond+ -> block {|x| boolean}, filtering entities upon iterations
  # * *Returns* :
  #   - hash of {entity.id => entity.name}
  #
  def make_select_list( model, &cond )
    cond ||= proc { true } # cond defaults to proc { true }
    # Entities filtered by cond, followed by filtration by (id, name)
    model.all.map do |x|
      cond.( x ) ? { x.id => x.name } : {}
    end.reduce Hash.new do |memo, e| memo.merge( e ) end
  end

Danach können Sie diese Funktion folgendermaßen aufrufen:

@contests = make_select_list Contest do |contest|
  logged_admin? or contest.organizer == @current_user
end

Wenn Sie Ihre Auswahl nicht filtern müssen, lassen Sie den Block einfach weg:

@categories = make_select_list( Category ) # selects all categories

Soviel zur Kraft der Ruby-Blöcke.

Sie können auch "eval" verwenden, die Methode als Zeichenfolgenargument übergeben und sie dann einfach in der anderen Methode auswerten.