[英]Instance_eval: why the class of subclass is superclass
def singleton_class
class << self
self
end
end
class Human
proc = lambda { puts 'proc says my class is ' + self.name.to_s }
singleton_class.instance_eval do
define_method(:lab) do
proc.call
end
end
end
class Developer < Human
end
Human.lab # class is Human
Developer.lab # class is Human ; oops
Following solution works. 以下解决方案有效
def singleton_class
class << self
self
end
end
class Human
proc = lambda { puts 'proc says my class is ' + self.name.to_s }
singleton_class.instance_eval do
define_method(:lab) do
self.instance_eval &proc
end
end
end
class Developer < Human
end
Human.lab # class is Human
Developer.lab # class is Human ; oops
Why Developer.lab is reporting that it is Human ? 为什么Developer.lab报告它是Human? And what can be done so that proc reports Developer when Developer.lab is invoked.
还有什么可以让proc在调用Developer.lab时报告Developer。
The closure is capturing self in the context where it is defined - just like closures should do. 闭包是在定义它的上下文中捕获self - 就像闭包应该做的那样。 So, when it is called, it will use the references to the context it captured.
因此,当它被调用时,它将使用对它捕获的上下文的引用。 A closure is not the ideal tool to define the intended functionality.
闭包不是定义预期功能的理想工具。 Instead of proc.call, the content of the "define_method" invocation should be "puts 'proc says my class is ' + name.to_s"
而不是proc.call,“define_method”调用的内容应该是“puts”,proc表示我的类是'+ name.to_s'
It's subtle, but it boils down to simply calling the block (in which case it acts as a normal closure, and self
corresponds to where it was defined, ie in Human
), or using it (directly) as a block for a method definition or instance_eval
: 它是微妙的,但它归结为简单地调用块(在这种情况下,它充当正常闭包,
self
对应于它定义的位置,即在Human
),或者使用它(直接)作为方法定义的块或instance_eval
:
def singleton_class
class << self
self
end
end
class Human
PROC = proc { puts 'proc says my class is ' + self.name.to_s }
singleton_class.instance_eval do
define_method(:lab) do
PROC.call
end
define_method(:lab2, &PROC.method(:call))
define_method(:lab3) do
instance_eval(&PROC)
end
define_method(:lab4, &PROC)
end
end
class Developer < Human
end
Human::PROC.call # => "class is Human" (original closure)
Developer.lab # Same as previous line, so "class is Human" (original closure)
Developer.lab2 # ditto
Developer.instance_eval(&Human::PROC) # => "class is Developer" (instance_eval changes sets a different scope)
Developer.lab3 # Same as previous line, so "class is Developer"
Developer.lab4 # ditto
I have to think a little bit about exactly why this works, but for the moment it does work: 我必须仔细考虑一下它为什么会起作用,但目前它确实有效:
class Human
proc = -> { name }
define_singleton_method(:lab, &proc)
end
class Developer < Human; end
require 'test/unit'
class TestClosures < Test::Unit::TestCase
def test_that_the_human_class_is_named_human
assert_equal 'Human', Human.lab
end
def test_that_the_developer_class_is_named_developer
assert_equal 'Developer', Developer.lab
end
end
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.