ruby - 一个变量可以在一个 block 内改变吗？

Question

我们直接上代码:

#!/usr/bin/ruby
 require 'tk'


class Epg

def initialize
    @var = "bad"    
    @cvs = nil  
    @items_demo = TkRoot.new() {title "EPG"}
    TkFrame.new(@items_demo) {|cf|
          @var = "good" 
          @cvs = TkCanvas.new(cf) {|c|}
        puts  "@cvs 1  is #{@cvs}"
        puts  "@var 1 is #{@var}"
    }.pack('side'=>'top', 'fill'=>'both', 'expand'=>'yes')

    puts  "@cvs 2 is #{@cvs}"
    puts  "@var 2 is #{@var}"

end #initialize

def test
    @var = "bad"
    puts " @var 3 :#{@var}"
    (1..3).each {|x| @var="good"}
    puts " @var 4 :#{@var}"
end
 end

 e= Epg.new 
 e.test 

这是输出:

@cvs 1  is #<Tk::Canvas:0xb7cecb08>
@var 1 is good
@cvs 2 is 
@var 2 is bad           #@var has NOT been changed by the code in the block
@var 3 :bad
@var 4 :good            #@var has been changed by the code in the block

为什么我们在这里看到不同的行为？

Answer 1

您可以将 block 视为同时关闭局部变量集和当前 self。

在 Ruby 中，无论如何，您都总是可以访问局部变量。 self 封装了当前对象的实例方法以及实例变量。

考虑以下代码:

class Table
  def initialize(legs)
    @legs = legs
  end

  def with_legs
    yield @legs
  end
end

然后:

def some_calling_method
  name = "Yehuda"
  Table.new(4) {|legs| puts "#{name} gnaws off one of the #{legs} legs" }
end

通过 Ruby 的 block 语义，您可以确信 name 将在 block 内可用，即使不查看您正在调用的方法也是如此。

但是，请考虑以下几点:

class Person
  def initialize(name)
    @name = name
  end

  def gnaw
    Table.new(4).with_legs do |legs| 
      puts "#{@name} gnaws off one of the #{legs} legs"
    end
  end
end

Person.new("Yehuda").gnaw

在这种情况下，我们从 block 内部访问 @name 实例变量。它在这种情况下效果很好，但不能保证。如果我们以不同的方式实现表会怎样:

class Table
  def initialize(legs)
    @legs = legs
  end

  def with_legs(&block)
    self.instance_eval(&block)
  end
end

实际上，我们所说的是“在不同 self 的背景下评估障碍”。在这种情况下，我们正在表的上下文中评估 block 。你为什么要这样做？

class Leg
  attr_accessor :number
  def initialize(number)
    @number = number
  end
end

class Table
  def initialize(legs)
    @legs = legs
  end

  def with_leg(&block)
    Leg.new(rand(@legs).instance_eval(&block)
  end
end

现在，您可以:

class Person
  def initialize(name)
    @name = name
  end

  def gnaw
    Table.new(4).with_leg do
      puts "I'm gnawing off one of leg #{number}"
    end
  end
end

如果你想访问 block 内的 person 对象，你必须这样做:

class Person
  def initialize(name)
    @name = name
  end

  def gnaw
    my_name = name
    Table.new(4).with_leg do
      puts "#{my_name} is gnawing off one of leg #{number}"
    end
  end
end

如您所见，使用 instance_eval 可以使访问 block 内远处对象的方法变得更简单、体积更小，但代价是使 self 不可访问。该技术通常用于 DSL，其中将许多方法注入(inject)到 block 中，但 self 并不重要。

这就是 Tk 正在发生的事情；他们正在使用 instance_eval 将他们自己的 self 注入(inject)到 block 中，这会将你的 self 擦干净。