Ruby'de bir yöntemi parametre olarak geçirmek

Ruby ile biraz uğraşmaya çalışıyorum. Bunun için Ruby "Programming Collective Intelligence" kitabındaki algoritmaları (Python'da verilen) uygulamaya çalışıyorum.

Bölüm 8'de yazar bir yöntemi parametre olarak geçirir. Bu Python'da çalışıyor gibi görünüyor ama Ruby'de değil.

Burada yöntemim var

def gaussian(dist, sigma=10.0)
  foo
end

ve bunu başka bir yöntemle çağırmak istiyorum

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

Tek sahip olduğum bir hata

ArgumentError: wrong number of arguments (0 for 1)

Bir proc nesnesi istiyorsunuz:

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

Bunun gibi bir blok bildiriminde varsayılan bir argüman ayarlayamayacağınızı unutmayın. Bu yüzden bir uyarı kullanmanız ve proc kodunun kendisinde varsayılanı ayarlamanız gerekir.

Veya, tüm bunların kapsamına bağlı olarak, bunun yerine bir yöntem adı geçirmek daha kolay olabilir.

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

Bu durumda, tam bir kod yığınını iletmek yerine, yalnızca bir nesne üzerinde tanımlanmış bir yöntemi çağırırsınız. Bunu nasıl yapılandırdığınıza bağlı olarak self.send,object_that_has_the_these_math_methods.send

Son fakat en az değil, yönteme bir blok asabilirsiniz.

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

Ancak, burada daha fazla yeniden kullanılabilir kod parçası istiyorsunuz gibi görünüyor.

Bloklara ve Proc'lara atıfta bulunan yorumlar, Ruby'de daha yaygın oldukları için doğrudur. Ama isterseniz bir yöntemi geçebilirsiniz. Sen buna methodyöntemini almak ve .callaramak için:

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

Bir yöntemi parametre olarak method(:function)yolla iletebilirsiniz . Aşağıda çok basit bir örnek var:

def double (a)
  a * 2 döndür 
son
=> sıfır

def method_with_function_as_param (geri arama, numara) 
  callback.call (sayı) 
son 
=> sıfır

method_with_function_as_param (yöntem (: çift), 10) 
=> 20

Bunu yapmanın normal Ruby yolu bir blok kullanmaktır.

Yani şöyle bir şey olurdu:

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

Ve şu şekilde kullanılır:

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

Bu kalıp Ruby'de yaygın olarak kullanılmaktadır.

Yöntemi bir bloğa dönüştürmek için yönteminizin örneğindeki &operatörü kullanabilirsiniz .Method

Misal:

def foo(arg)
  p arg
end

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

bar(&method(:foo))

Daha fazla ayrıntı http://weblog.raganwald.com/2008/06/what-does-do-when-used-as-unary.html adresinde

İşlev nesnesinin "call" yöntemini çağırmanız gerekir:

weight = weightf.call( dist )

DÜZENLEME: Yorumlarda açıklandığı gibi, bu yaklaşım yanlış. Normal işlevler yerine Procs kullanıyorsanız işe yarar.

Bir işlev içindeki adlandırılmış bloklara erişim sağlamak için "ve" işaretini kullanmanızı tavsiye ederim. Bu makalede verilen önerileri takip ederek şöyle bir şey yazabilirsiniz (bu benim çalışma programımdan gerçek bir nottur):

  # 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

Afterwerds, bu işlevi şu şekilde çağırabilirsiniz:

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

Seçiminizi filtrelemeniz gerekmiyorsa, bloğu atlamanız yeterlidir:

@categories = make_select_list( Category ) # selects all categories

Ruby bloklarının gücü için çok fazla.

Ayrıca, "eval" öğesini kullanabilir ve yöntemi bir dizge bağımsız değişkeni olarak iletebilir ve ardından onu diğer yöntemde değerlendirebilirsiniz.