Czy "yield self" jest takie samo jak instance_eval?

Question

Czy jest jakaś różnica, jeśli zdefiniujesz Foo z instance_eval:. . .

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

. . . lub „ja dochodowości”:

class Foo 
    def initialize 
    yield self if block_given? 
    end 
end 

W obu przypadkach można to zrobić:

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

Więc „yield self” oznacza, że ​​blok po Foo.new zawsze jest oceniana w kontekście z Klasa Foo.

Czy to prawda?

Answer 1

Twoje dwie części kodu robią bardzo różne rzeczy. Korzystając z klasy instance_eval, oceniasz blok w kontekście obiektu. Oznacza to, że użycie def definiuje metody na tym obiekcie. Oznacza to również, że wywołanie metody bez odbiornika wewnątrz bloku spowoduje wywołanie go na obiekcie.

Kiedy ustępujesz, podajesz siebie jako argument do bloku, ale ponieważ twój blok nie przyjmuje żadnych argumentów, jest po prostu ignorowany. Więc w tym przypadku oddanie siebie robi to samo, co nie daje niczego. def zachowuje się tutaj dokładnie tak, jak poza tym blokiem, dając samo siebie nie zmienia tego, na co definiujesz metodę. Co można zrobić, to:

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

Różnica do instance_eval jest, że trzeba określić odbiornik wyraźnie.

Edycja wyjaśnienie:

W wersji z wydajnością obj w bloku jest obiekt, który jest uzyskane, która w tym przypadku jest to nowoutworzone przykład foo. Podczas gdy jaźń będzie miała taką samą wartość, jaką miała poza blokiem. Dzięki instancji instance_eval w wersji self wewnątrz bloku zostanie utworzona nowo utworzona instancja Foo.

Answer 2

Po prostu można usunąć Własna słowa kluczowego

class Foo 
    def initialize 
    yield if block_given? 
    end 
end 

Update z uwag

Korzystanie wydajność jest nieco nowego do mojego gustu, szczególnie kiedy jest stosowany poza IRB.

Jednak istnieje duża i znacząca różnica pomiędzy instance_eval podejścia i wydajność podejścia, sprawdź ten fragment:

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> 

sprawdzić ten jeden, a także:

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" 

jak można widzimy różnicę polegającą na tym, że pierwsza z nich dodaje metodę singleton do inicjowanego obiektu, whil e później dodaje prywatną metodę do wszystkich instancji klasy Object.

Answer 3

Są różne. yield(self) nie zmienia wartości self wewnątrz bloku, natomiast ma wartość instance_eval(&block).

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