欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Ruby常量查找路径问题深入研究

程序员文章站 2022-11-15 19:39:08
ruby 的常量查找路径问题是一直困扰我的一个问题,在工作中遇到过好几次,一直没有彻底弄清楚到底为什么,最近在读一本书《ruby 元编程》,对 ruby 对象模型有了更深入...

ruby 的常量查找路径问题是一直困扰我的一个问题,在工作中遇到过好几次,一直没有彻底弄清楚到底为什么,最近在读一本书《ruby 元编程》,对 ruby 对象模型有了更深入的认识,另外读了一篇 blog《everything you ever wanted to know about constant lookup in ruby》, 让我总算把 ruby 常量查找路径这个问题搞得比较清楚。

第一个遇到的问题,我还曾经在 ruby-china 上发过帖。

复制代码 代码如下:

module m1
  ct = "ok"
end

class c1
  ck = "ck"
  include m1

  def self.method1
    puts self
    puts "#{ck} in method1"
    puts "#{ct} in method1"
  end

  class << self
    def method2
      puts self
      puts "#{ck} in method1"
      puts "#{ct} in method2"
    end
  end
end

c1.method1
c1.method2

输出结果是

复制代码 代码如下:

c1
ck in method1
ok in method1
c1
ck in method2
nameerror: uninitialized constant class::ct
    from (irb):16:in `method2'

这是我在重构薄荷网代码时候遇到的问题,method1 和 method2 都是常见的类方法的定义方面,我向来认为它们是等价可替换的写法,但是从实际执行的结果看,它们里面的常量查找路径不一样。

如果我把 m1 的定义改成下面的样子:

复制代码 代码如下:

module m1
  def self.included(base)
    base.extend(self)
  end
  ct = "ok"
end

执行结果是:

复制代码 代码如下:

c1
ck in method1
ok in method1
c1
ck in method2
ok in method2

还有一个问题是也是经常遇到的,抽象成问题代码如下:

复制代码 代码如下:

module a
  module m
    def a_method
      #...
    end
  end
end

class a::b
  include m
end

会报异常:

复制代码 代码如下:

nameerror: uninitialized constant a::b::m
  from (irb):10:in `<class:b>'

ruby 常量查找时依据两条路径

a. module.nesting
b. open class/module 的 ancestors

a 比 b 优先,a 找不到了才到 b 中查找。

a.module.nesting 的概念比较容易理解,它是指代码位置的 module 嵌套情况,它是一个数组,从最内层的嵌套一直到最外层的嵌套,如果没有嵌套,数组为空。任何一处代码位置都有 module.nesting 值,可以通过下面的代码打印出各个位置的 module.nesting 值。

复制代码 代码如下:

p module.nesting

module a
  module b
    p module.nesting
    module c
      p module.nesting
    end
  end
end

module a::b
  p module.nesting
end

输出是:

复制代码 代码如下:

[]
[a::b, a]
[a::b::c, a::b, a]
[a::b]

大家有没有注意到,module a::b 这种快捷写法会导致 a 不在 module.nesting 里,这就是上述第二个问题的根源,因为 m 是 a module 下的常量,module a::b 写法导致不会查找 a::m。

说完 a module.nesting,再说一下 b open class/module 的 ancestors,这个问题相对复杂很多。简单的说,在 ruby 代码的任何位置,都有一个 self 存在,同样也有一个 open class/module 存在,在模块和类定义处,它通常就是对应的模块和类,在方法内部,它是方法对应的类。对于 ancestors,我们可以通过代码位置 open class/module 的 ancestors 方法取得。

(备注:ancestors 在引入 singleton_class 概念之后变得有点复杂,如不清楚可参考《ruby 元编程》)

上述第一个问题: 在method1 中 a 是 [c1] open class/module 是 c1,所以 ancestors 是 [c1, m1, object, kernel, basicobject] ck 在 a 可以找到,ct 在 b 可以找到。

method2 中 a 是 [c1] open class/module 是 c1 的 singleton_class , 所以 ancestors 是 [class, module, object, kernel, basicobject] ck 在 a 可以找到,ct 在 a 和 b 都找不到。

对于

复制代码 代码如下:

module m1
  def self.included(base)
    base.extend(self)
  end
  ct = "ok"
end

可运行,是因为这时,在 method2 中,open class/module c1 的 singleton_class 扩展了 m1,所以 ancestors 变成了 [m1, class, module, object, kernel, basicobject]。

至此,这两个困扰我多时的问题终于彻底搞清楚了。这个过程给我的一个体会是:面对技术上的一些疑问,如果只是浅尝辄止,是永远不能够真正掌握它的,只有深入专研,透彻理解它的原理,才能够真正掌握它,获得真正的能力提升。