Jak przekazywać argumenty do metody define_method?

Question

Chciałbym przekazać argument (y) do metody zdefiniowanej przy użyciu metody define_method, w jaki sposób mogę to zrobić?

Answer 1

Blok przekazywany do metody define_method może zawierać niektóre parametry. W ten sposób zdefiniowana metoda przyjmuje argumenty. Kiedy definiujesz metodę, tak naprawdę po prostu przezwiskasz blok i zachowujesz odniesienie do niego w klasie. Parametry pochodzą z bloku. Więc:

define_method(:say_hi) { |other| puts "Hi, " + other } 

Answer 2

Oprócz odpowiedź Kevin Conner za: argumenty blokowych nie obsługują te same semantykę jako argumenty metod. Nie można definiować domyślnych argumentów ani argumentów blokowych.

Zostało to naprawione tylko w Rubim 1.9 z nową alternatywną składnią "skurczona lambda", która obsługuje semantykę pełnego argumentu metody.

Przykład:

# Works 
def meth(default = :foo, *splat, &block) puts 'Bar'; end 

# Doesn't work 
define_method :meth { |default = :foo, *splat, &block| puts 'Bar' } 

# This works in Ruby 1.9 (modulo typos, I don't actually have it installed) 
define_method :meth, ->(default = :foo, *splat, &block) { puts 'Bar' } 

Answer 3

... a jeśli chcesz opcjonalne parametry

class Bar 
    define_method(:foo) do |arg=nil|     
    arg                       
    end 
end 

a = Bar.new 
a.foo 
#=> nil 
a.foo 1 
# => 1 

... jak wiele argumentów, ile chcesz

class Bar 
    define_method(:foo) do |*arg|     
    arg                       
    end 
end 

a = Bar.new 
a.foo 
#=> [] 
a.foo 1 
# => [1] 
a.foo 1, 2 , 'AAA' 
# => [1, 2, 'AAA'] 

... kombinacja

class Bar 
    define_method(:foo) do |bubla,*arg| 
    p bubla     
    p arg                       
    end 
end 

a = Bar.new 
a.foo 
#=> wrong number of arguments (0 for 1) 
a.foo 1 
# 1 
# [] 

a.foo 1, 2 ,3 ,4 
# 1 
# [2,3,4] 

... wszyscy

class Bar 
    define_method(:foo) do |variable1, variable2,*arg, &block| 
    p variable1  
    p variable2 
    p arg 
    p block.inspect                    
    end 
end 
a = Bar.new  
a.foo :one, 'two', :three, 4, 5 do 
    'six' 
end 

Aktualizacja

Ruby 2.0 wprowadzono podwójne ikona ** (dwie gwiazdki), która (I quote) robi:

Ruby 2.0 wprowadzone argumenty słów kluczowych i ** działa jak *, ale dla argumentów słów kluczowych. Zwraca Hash z parami klucz/wartość.

... i oczywiście można go używać na określenie metody zbyt :) przykład

class Bar 
    define_method(:foo) do |variable1, variable2,*arg,**options, &block| 
    p variable1 
    p variable2 
    p arg 
    p options 
    p block.inspect 
    end 
end 
a = Bar.new 
a.foo :one, 'two', :three, 4, 5, ruby: 'is awesome', foo: :bar do 
    'six' 
end 
# :one 
# "two" 
# [:three, 4, 5] 
# {:ruby=>"is awesome", :foo=>:bar} 

Nazwany atrybuty:

class Bar 
    define_method(:foo) do |variable1, color: 'blue', **other_options, &block| 
    p variable1 
    p color 
    p other_options 
    p block.inspect 
    end 
end 
a = Bar.new 
a.foo :one, color: 'red', ruby: 'is awesome', foo: :bar do 
    'six' 
end 
# :one 
# "red" 
# {:ruby=>"is awesome", :foo=>:bar} 

starałem się tworzyć przykład ze słowem kluczowym argumentem, ikona w postaci splat i podwójnej: w jednym:

define_method(:foo) do |variable1, variable2,*arg, i_will_not: 'work', **options, &block| 
    # ... 

lub

define_method(:foo) do |variable1, variable2, i_will_not: 'work', *arg, **options, &block| 
    # ... 

... ale to nie zadziała, wygląda na to, że istnieje ograniczenie. Kiedy myślisz o tym ma sens, operatorem splat jest "przechwytywanie wszystkich pozostałych argumentów", a podwójna ikona to "przechwytywanie wszystkich pozostałych argumentów słów kluczowych", dlatego ich mieszanie przerwałoby oczekiwaną logikę. (Nie mam żadnego odniesienia, aby udowodnić ten punkt!)

Answer 4

Z 2.2 można teraz używać argumentów słowa kluczowego: https://robots.thoughtbot.com/ruby-2-keyword-arguments

define_method(:method) do |refresh: false| 
    .......... 
end