objetos - proc ruby

ruby: ¿puede un bloque afectar variables locales en un método?

Question

Estoy aprendiendo ruby ​​y tratando de entender el alcance del código ejecutado en bloques. Por ejemplo, quiero poder crear un bloque que afecte el método al que está conectado, así:

def test(&block)
  block.call() if block_given?
  puts "in test, foo is #{foo}"
  puts "in test, bar is #{bar}"
end

test() {
  foo="this is foo"
  bar="this is bar"
}

En este caso, no quiero tener que modificar el bloque en absoluto; quiero poder escribirlo usando referencias de variables simples y sin parámetros. Solo haciendo cambios al método de ''prueba'' en el ejemplo anterior , ¿es posible acceder a las variables definidas en el bloque?

De nuevo, el objetivo es dejar el bloque sin modificar, pero poder acceder a las variables creadas desde ''prueba'' después de que se ejecute el bloque.

Answer 1

def test(&block)
  foo = yield
  puts "in test, foo is #{foo}"
end

test { "this is foo" }

impresiones in test, foo is this is foo

El valor del rendimiento es el valor del bloque.

También puede pasar parámetros para ceder, a los que luego se puede acceder mediante el bloque usando | param, otro | al comienzo del bloque.

Además, mira los procs.

foo = "this is foo"
p = Proc.new { "foo is #{foo}" }
p.call

Imprime "foo is this is foo"

def test(p) 
  p.call
end

test p

Imprime "foo is this is foo"

def test2(p)
  foo = "monkey"
  p.call
end

test2 p

Imprime "foo is this is foo"

Answer 2

No, un bloque no puede afectar las variables locales en el lugar donde se llama.

Los bloques en Ruby son cierres , lo que significa que capturan el alcance a su alrededor cuando se crean. Las variables que son visibles cuando crea el bloque son las que ve. Si hubiera un foo y una bar en la parte superior de tu código, fuera de cualquier método, ese bloque los cambiaría cuando se llamara.

Answer 3

Puedes hacer lo que quieras siendo un poco más detallado:

class Test
  def foo(t)
    @foo = t
  end
  def bar(t)
    @bar = t
  end
  def test(&block)
    self.instance_eval &block if block_given?
    puts "in test, foo is #{@foo}"
    puts "in test, bar is #{@bar}"
  end
end

Test.new.test() {
  foo "this is foo"
  bar "this is bar"
}

Puede crear métodos como attr_accessor que generarán un setter apropiado (los métodos foo y bar ).

Answer 4

En primer lugar, block.call() se realiza con yield , y no necesita el parámetro &block esa manera.

Normalmente no puede hacer lo que quiere, los bloques están vinculados cuando se crean, y dentro del bloque puede ver las variables locales definidas en ese momento; La forma más fácil de hacer lo que desea, que no es cómo usará los bloques normalmente, es esta:

def test()
  foo = yield if block_given?
  puts "in test, foo is #{foo}"
end

test() {
  foo="this is foo"
}

Pero eso es solo un efecto secundario porque foo es "devuelto" por el bloque. Si en cambio haces esto:

def test()
  foo = yield if block_given?
  puts "in test, foo is #{foo}"
end

test() {
  foo="this is foo"
  "ha ha, no foo for you"
}

Notarás que hace algo diferente.

Aquí hay más magia:

def test(&block)
   foo = eval "foo", block.binding
   puts foo
   block.call
   foo = eval "foo", block.binding
   puts foo
end

foo = "before test"
test() {
  foo = "after test"
  "ha ha, no foo for you"
}

Eso funcionaría, pero se rompe si eliminas foo = "before test" porque foo convierte en una variable local en el bloque y no existe en el enlace.

Resumen: no se puede acceder a las variables locales desde un bloque, solo los locales donde se definió el bloque y el valor de retorno del bloque.

Incluso esto no funcionará:

def test(&block)
   eval "foo = ''go fish''", block.binding
   block.call
   bar = eval "foo", block.binding
   puts bar
end

porque el foo en el enlace es diferente del local en el bloque (no lo sabía, gracias).