Comment passez-vous les arguments à define_method?

Question

Je voudrais passer un argument (s) à une méthode en cours de définition en utilisant define_method, comment ferais-je cela?

Answer 1

Le bloc que vous passez à define_method peut inclure certains paramètres. C'est ainsi que votre méthode définie accepte les arguments. Lorsque vous définissez une méthode, vous ne faites que nickname le bloc et gardez une référence dans la classe. Les paramètres viennent avec le bloc. Alors:

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

Answer 2

En plus de réponse de Kevin Conner: les arguments de bloc ne supportent pas la même sémantique que les arguments de méthode. Vous ne pouvez pas définir les arguments par défaut ou les arguments de blocage.

Ceci n'est corrigé que dans Ruby 1.9 avec la nouvelle syntaxe alternative "stabby lambda" qui prend en charge la sémantique d'argument de méthode complète.

Exemple:

# 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

... et si vous voulez des paramètres facultatifs

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

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

... autant d'arguments que vous voulez

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'] 

... combinaison de

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] 

... tous

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 

Mise à jour

Ruby 2.0 introduit deux floc ** (deux étoiles) qui (I quote) fait:

Ruby 2.0 introduit des arguments clés , et ** agit comme *, mais pour les arguments de mots-clés. Il renvoie un hachage avec des paires clé/valeur.

... et bien sûr, vous pouvez l'utiliser à définir dans la méthode aussi :)

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} 

nommé attributs par exemple:

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} 

je tentais de créer par exemple avec l'argument de mot-clé, splat et double splat tout en un:

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

ou

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

... mais cela ne fonctionnera pas, il semble qu'il y ait une limitation. Quand vous y réfléchissez, cela prend tout son sens car l'opérateur splat "capture tous les arguments restants" et double splat "capture tous les arguments de mots-clés restants". Par conséquent, les mélanger briserait la logique attendue. (Je n'ai aucune référence pour prouver ce point doh!)

Answer 4

Avec 2.2 vous pouvez maintenant utiliser des arguments clés: https://robots.thoughtbot.com/ruby-2-keyword-arguments

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