Ist 'Ausbeute selbst" das gleiche wie instance_eval?

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

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

. . . oder mit 'yield self':

class Foo
  def initialize
    yield self if block_given?
  end
end

In jedem Fall, dass Sie dies tun können:

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

So 'yield self' bedeutet, dass der block nach Foo.neues wird immer ausgewertet, die im Rahmen der Foo-Klasse.

Ist das richtig?

InformationsquelleAutor uzo | 2009-09-15
  1. 15

    Deine beiden code-Stücken, die die unterschiedlichsten Dinge tun. Durch die Verwendung instance_eval du bist der Bewertung der block in den Kontext des Objekts. Dies bedeutet, dass mit def definieren Methoden auf das Objekt. Es bedeutet auch, dass der Aufruf einer Methode ohne Empfänger in den block, rufen Sie es auf Ihrem Objekt.

    Wenn was selbst Sie übergeben haben selbst als argument für den block, aber da dein block nimmt keine Argumente, es wird einfach ignoriert. Also in diesem Fall das nachgeben selbst macht das gleiche wie nachgeben nichts. Die def hier verhält sich genau wie ein def außerhalb des Blocks würde, was selbst nicht wirklich was ändern, definieren Sie die Methode auf. Was Sie tun können, ist:

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

    Den Unterschied zu instance_eval sein, dass Sie zum angeben der Empfänger ausdrücklich.

    Bearbeiten, um zu klären:

    In der version mit Ertrag -, obj -, die in dem block wird das Objekt, das sich ergab, in diesem Fall wird die neu erstellte Foo-Instanz. Während selbst die haben den gleichen Wert, den es hatte außerhalb des Blocks. Mit der instance_eval version self innerhalb des Blocks werden die neu erstellten Foo-Instanz.

    • In Ihrem "Bearbeiten, um zu klären", meinst du nicht auch bedeuten, dass selbst ergab sich das obj in den block? Vielleicht bin ich auch nur Lesen, es anders aber ich sehe das Objekt wird initialisiert, selbst ergab sich der block als 'obj' und dann in den block, wird die Methode foo ist definiert selbst durch obj.
    • Ich bin mir ziemlich sicher, dass wir das gleiche meinen. Ich schrieb "die neu erstellte Foo-Instanz", weil ich in der initialize-Methode (das ist die neu erstellte Foo-Instanz) ist nicht das gleiche wie selbst in den block, und wenn Sie nur sagen, "selbst", es ist unklar, welche du meinst.
    InformationsquelleAutor sepp2k
  2. 8

    Sind Sie anders. yield(self) ändert nicht den Wert der self im inneren 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
    InformationsquelleAutor August Lilleaas
  3. 5

    Du nur ablegen können, die selbst Stichwort

    class Foo
  def initialize
    yield if block_given?
  end
end

    Update aus den Kommentaren

    Mit Ertrag es ist ein bisschen neu für meinen Geschmack, speziell, wenn draußen irb.

    Allerdings gibt es einen großen und signifikanten Unterschied zwischen instance_eval Ansatz und Ertrag Ansatz, check das snippet: 

    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>

    Überprüfen Sie diese 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 sehen können, der Unterschied ist, dass erstere ist das hinzufügen einer singleton-Methode foo auf das Objekt wird initialisiert, während das spätere hinzufügen einer privaten Methode, um alle Instanzen der Object-Klasse.

    • "Wie Sie sehen können, der Unterschied ist, dass erstere ist das hinzufügen einer singleton-Methode foo an das Objekt wird initialisiert, während die später Hinzugefügt werden, daß die Methode auf alle Instanzen der Klasse Foo2" Eigentlich das letztere ist das hinzufügen der Methode zum Objekt (und im wirklichen ruby (im Gegensatz zum irb-Ansatz), wird es fügen Sie es als eine private Methode man kann also nicht x zu tun.foo oder z ist.foo, nur foo). In anderen Worten, die def verhält sich genau so, wie wenn du geschrieben hättest es außerhalb des Blocks (es sei denn, die Methode nicht, die Ausbeute natürlich in dem Fall nichts passiert).
    • Sie sind absolut wahr, vielen Dank
    • In Ruby 1.9, Sie erhalten nicht die private Methode definition. Stattdessen x = Foo2.new { def foo"; "foo"; Ende } definieren Sie die Methode 'foo' auf das Objekt (wie sepp2k gesagt). Sie können dies sehen, indem man sagt: x.Methoden(false).grep /foo/ # => [] - Objekt.neue.foo # => "foo"
    InformationsquelleAutor khelll
Schreibe einen Kommentar