¿Es 'yield self' lo mismo que instance_eval?

Question

¿Hay alguna diferencia si define Foo con instance_eval:. . .

class Foo 
    def initialize(&block) 
     instance_eval(&block) if block_given? 
    end 
    end 

. . . o con 'auto rendimiento':

class Foo 
    def initialize 
    yield self if block_given? 
    end 
end 

En cualquiera de los casos se puede hacer esto:

x = Foo.new { def foo; 'foo'; end } 
x.foo 

Así 'yield self' significa que el bloque después Foo.new siempre se evalúa en el contexto de la Clase Foo

¿Es esto correcto?

Answer 1

Sus dos códigos hacen cosas muy diferentes. Al usar instance_eval está evaluando el bloque en el contexto de su objeto. Esto significa que usar def definirá métodos en ese objeto. También significa que llamar a un método sin un receptor dentro del bloque lo llamará a su objeto.

Al ceder uno mismo estás pasando uno mismo como un argumento al bloque, pero como tu bloque no toma ningún argumento, simplemente se ignora. Entonces en este caso rendirse a sí mismo hace lo mismo que no ceder nada. El def aquí se comporta exactamente como un def fuera del bloque, lo que produce uno mismo no cambia realmente lo que define el método. Lo que podría hacer es:

class Foo 
    def initialize 
    yield self if block_given? 
    end 
end 
x = Foo.new {|obj| def obj.foo() 'foo' end} 
x.foo 

La diferencia de instance_eval es que usted tiene que especificar explícitamente el receptor.

Editar para aclarar:

En la versión con rendimiento, obj en el bloque será el objeto que se produjo, que en este caso es es la instancia Foo recién creado. Mientras que uno mismo tendrá el mismo valor que tenía fuera del bloque. Con la versión de instance_eval self dentro del bloque se creará la instancia de Foo recién creada.

Answer 2

Sólo se puede quitar la palabra clave auto

class Foo 
    def initialize 
    yield if block_given? 
    end 
end 

actualización de los comentarios

Usando rendimiento hay un poco nueva para mi gusto, especialmente cuando se utiliza fuera del IRB.

Sin embargo, hay una diferencia grande y significativa entre instance_eval aproximación y enfoque del rendimiento, compruebe este fragmento:

class Foo 
    def initialize(&block) 
    instance_eval(&block) if block_given? 
    end 
end 
x = Foo.new { def foo; 'foo'; end }    
#=> #<Foo:0xb800f6a0>            
x.foo #=> "foo"               
z = Foo.new #=> #<Foo:0xb800806c>            
z.foo #=>NoMethodError: undefined method `foo' for #<Foo:0xb800806c> 

Comprobar éste a su vez:

class Foo2 
    def initialize 
    yield if block_given? 
    end 
end 
x = Foo2.new { def foo; 'foo'; end } #=> #<Foo:0xb7ff1bb4> 
x.foo #=> private method `foo' called for #<Foo2:0xb8004930> (NoMethodError) 
x.send :foo => "foo" 
z = Foo.new #=> #<Foo:0xb800806c> 
z.send :foo => "foo" 

Como se puede ver la diferencia es que el anterior está agregando un método singleton foo al objeto que se inicializa, cuando e el último agrega un método privado a todas las instancias de la clase Object.

Answer 3

Son diferentes. yield(self) no cambia el valor de self dentro del bloque, mientras que instance_eval(&block) sí lo hace.

class Foo 
    def with_yield 
    yield(self) 
    end 

    def with_instance_eval(&block) 
    instance_eval(&block) 
    end 
end 

f = Foo.new 

f.with_yield do |arg| 
    p self 
    # => main 
    p arg 
    # => #<Foo:0x100124b10> 
end 

f.with_instance_eval do |arg| 
    p self 
    # => #<Foo:0x100124b10> 
    p arg 
    # => #<Foo:0x100124b10> 
end