Comment les variables sont-elles liées au corps d'un define_method?

Question

En essayant de rafraîchir mes compétences Ruby je continue à courir à travers ce cas dont je ne peux pas trouver une explication en lisant simplement les documents de l'API. Une explication serait grandement appréciée. Voici l'exemple de code:

for name in [ :new, :create, :destroy ] 
    define_method("test_#{name}") do 
    puts name 
    end 
end 

Ce que je veux/vous attendre à arriver est que la variable name sera lié au bloc donné à define_method et que lorsque #test_new est appelée sortie sera « nouvelle ». A la place, chaque méthode définie sort "destroy" - la dernière valeur affectée à la variable name. Qu'est-ce que j'ai mal compris à propos de define_method et de ses blocs? Merci!

Answer 1

Les blocs en Ruby sont des fermetures: le bloc que vous passez à define_method capture lui-même la variable name - et non sa valeur - afin qu'elle reste dans la portée à chaque fois que ce bloc est appelé. C'est la première pièce du puzzle.

Le deuxième élément est que la méthode définie par define_methodest le bloc lui-même. Fondamentalement, il convertit un objet Proc (le bloc qui lui est passé) en un objet Method et le lie au récepteur.

Alors, que vous vous retrouvez avec est une méthode qui a capturé (est fermé sur) la variable name, qui par le temps que votre boucle Complètes est réglé sur :destroy.

Addition: La construction for ... in crée en fait une nouvelle variable locale, la construction [ ... ].each {|name| ... } correspondant ne pas faire. Autrement dit, votre boucle for ... in est équivalente à la suivante (en Ruby 1.8 de toute façon):

name = nil 
[ :new, :create, :destroy ].each do |name| 
    define_method("test_#{name}") do 
    puts name 
    end 
end 
name # => :destroy 

Answer 2

Le problème ici est que for expressions de boucle ne créent pas une nouvelle portée. Les seules choses qui créent de nouvelles portées dans Ruby sont les corps de script, les corps de module, les corps de classe, les corps de méthode et les blocs.

Si vous regardez réellement le comportement des for expressions en boucle dans le projet Ruby ISO spécifications, vous constaterez que l'expression de la boucle for est exécuté exactement comme un each iterator sauf le fait qu'il ne crée pas une nouvelle portée.

Aucun Rubyist ne jamais utiliser une boucle for, de toute façon: ils utiliseraient un itérateur à la place, qui -t prendre un bloc et crée ainsi une nouvelle portée.

Si vous utilisez un iterator idiomatiques, tout fonctionne comme prévu:

class Object 
    %w[new create destroy].each do |name| 
    define_method "test_#{name}" do 
     puts name 
    end 
    end 
end 

require 'test/unit' 
require 'stringio' 
class TestDynamicMethods < Test::Unit::TestCase 
    def setup; @old_stdout, $> = $>, (@fake_logdest = StringIO.new) end 
    def teardown; $> = @old_stdout end 

    def test_that_the_test_create_method_prints_create 
    Object.new.test_create 
    assert_equal "create\n", @fake_logdest.string 
    end 
    def test_that_the_test_destroy_method_prints_destroy 
    Object.new.test_destroy 
    assert_equal "destroy\n", @fake_logdest.string 
    end 
    def test_that_the_test_new_method_prints_new 
    Object.new.test_new 
    assert_equal "new\n", @fake_logdest.string 
    end 
end 

Answer 3

for name in [ :new, :create, :destroy ] 
    local_name = name 
    define_method("test_#{local_name}") do 
    puts local_name 
    end 
end 

Cette méthode se comportera comme prévu. La raison de la confusion est que 'nom' n'est pas créé une fois par itération de la boucle for. Il est créé une fois et incrémenté. De plus, si je comprends bien, les définitions de méthodes ne sont pas des fermetures comme les autres blocs. Ils conservent une visibilité variable, mais ne se referment pas sur la valeur actuelle des variables.