Ist 'yield self' das selbe wie instance_eval?

Question

Gibt es einen Unterschied, wenn Sie Foo mit instance_eval definieren:. . .

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

. . . oder mit 'Ausbeute Selbst':

class Foo 
    def initialize 
    yield self if block_given? 
    end 
end 

In jedem Fall können Sie dies tun:

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

So 'yield self' bedeutet, dass der Block nach Foo.new immer im Zusammenhang mit der ausgewertet wird Foo Klasse.

Ist das korrekt?

Answer 1

Ihre zwei Code-Teile machen sehr unterschiedliche Dinge. Mit instance_eval werten Sie den Block im Kontext Ihres Objekts aus. Dies bedeutet, dass die Verwendung von def Methoden für dieses Objekt definiert. Es bedeutet auch, dass das Aufrufen einer Methode ohne einen Empfänger innerhalb des Blocks es auf Ihrem Objekt aufrufen wird.

Wenn Sie self übergeben, übergeben Sie self als Argument an den Block, aber da Ihr Block keine Argumente annimmt, wird er einfach ignoriert. Also in diesem Fall macht das Ergebene das selbe wie nichts. Die def verhält sich hier genau wie eine def außerhalb des Blocks würde, ergibt sich nicht tatsächlich ändern, was Sie definieren die Methode auf. Was Sie tun könnten, ist:

Der Unterschied zu instance_eval ist, dass Sie den Empfänger explizit angeben müssen.

bearbeiten zu klären:

In der Version mit Ausbeute obj in dem Block das Objekt sein, das ergibt, der in diesem Fall ist die neu geschaffene Instanz Foo. Während das Selbst den gleichen Wert haben wird, hatte es außerhalb des Blocks. Mit der instance_eval Version self innerhalb des Blocks wird die neu erstellte Foo-Instanz sein.

Answer 2

Sie können nur die Stichwort

selbst drop

class Foo 
    def initialize 
    yield if block_given? 
    end 
end 

Update von Kommentaren

Mit Ausbeute es ein bisschen nach meinem Geschmack neu ist, besonders, wenn sie außerhalb irb verwendet.

Allerdings gibt es einen großen und bedeutenden Unterschied zwischen instance_eval Ansatz und Ausbeute Ansatz, lesen Sie in diesem Code-Schnipsel:

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> 

prüfen dieses auch:

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" 

Wie Sie können Der Unterschied besteht darin, dass der erste eine Singleton-Methode foo zu dem Objekt hinzufügt, das initialisiert wird e Das letztere fügt allen Instanzen der Object-Klasse eine private Methode hinzu.

Answer 3

Sie sind anders. yield(self) ändert nicht den Wert von self innerhalb des Blocks, während instance_eval(&block) tut.

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