Ruby 模块中常量的范围

Question

我在 mixin 模块中的恒定范围方面遇到了一些问题。假设我有这样的

module Auth

  USER_KEY = "user" unless defined? USER_KEY

  def authorize
    user_id = session[USER_KEY]
  def

end

USER_KEY 常量应默认为“user”，除非它已经定义。现在我可能会将其混合到几个地方，但在其中一个地方 USER_KEY 需要不同，所以我们可能有这样的东西

class ApplicationController < ActionController::Base

  USER_KEY = "my_user"

  include Auth

  def test_auth
    authorize
  end

end

我希望 USER_KEY 在授权中使用时将是“my_user”，因为它已经定义了，但它仍然是“用户”，取自 USER_KEY 的模块定义。有人知道如何获得使用 USER_KEY 类版本的授权吗？

Answer 1

您在 Auth 中声明（甚至有条件）的 USER_KEY 在全球范围内称为 Auth::USER_KEY。它不会“混合”到包含模块中，尽管包含模块可以以非完全限定的方式引用密钥。

如果您希望每个包含模块（例如 ApplicationController）能够定义自己的 USER_KEY，请尝试以下操作：

module Auth
  DEFAULT_USER_KEY = 'user'
  def self.included(base)
    unless base.const_defined?(:USER_KEY)
      base.const_set :USER_KEY, Auth::DEFAULT_USER_KEY
    end
  end
  def authorize
    user_id = session[self.class.const_get(:USER_KEY)]
  end
end

class ApplicationController < ActionController::Base
  USER_KEY = 'my_user'
  include Auth
end

不过，如果您要遇到所有这些麻烦，您不妨将其设为类方法：

module Auth
  DEFAULT_USER_KEY = 'user'
  def self.included(base)
    base.extend Auth::ClassMethods
    base.send :include, Auth::InstanceMethods
  end
  module ClassMethods
    def user_key
      Auth::DEFAULT_USER_KEY
    end
  end
  module InstanceMethods
    def authorize
      user_id = session[self.class.user_key]
    end
  end
end

class ApplicationController < ActionController::Base
  def self.user_key
    'my_user'
  end
end

或类级访问器：

module Auth
  DEFAULT_USER_KEY = 'user'
  def self.included(base)
    base.send :attr_accessor :user_key unless base.respond_to?(:user_key=)
    base.user_key ||= Auth::DEFAULT_USER_KEY
  end
  def authorize
    user_id = session[self.class.user_key]
  end
end

class ApplicationController < ActionController::Base
  include Auth
  self.user_key = 'my_user'
end

Answer 2

Ruby 中的常量没有全局作用域。常量在任何范围内都是可见的，但您必须指定在哪里可以找到该常量。当你开始一个新的类、模块或 def 时，你就开始了一个新的作用域，如果你想要另一个作用域中的常量，你必须指定在哪里找到它。

X = 0
class C
  X = 1
  module M
    X = 2
    class D
      X = 3
      puts X          # => 3
      puts C::X       # => 1
      puts C::M::X    # => 2
      puts M::X       # => 2
      puts ::X        # => 0
    end
  end
end

Answer 3

这是一个简单的解决方案。

更改：

• 无需检查 USER_KEY 是否存在。
• 尝试查找接收器模块/类上的常量（在您的情况下它将是控制器）。如果存在，则使用它，否则使用默认模块/类（请参阅下文了解默认值）。

。

module Auth
  USER_KEY = "user"

  def authorize
    user_key = self.class.const_defined?(:USER_KEY) ? self.class::USER_KEY : USER_KEY
    user_id = session[user_key]
  def
end

解释

您所看到的行为并非特定于 Rails，而是由于如果未通过 :: 显式限定作用域，则 ruby​​ 会查找常量（我称之为“默认”上面）。使用“当前执行代码的词法范围”查找常量。这意味着 ruby​​ 首先在执行代码的模块（或类）中查找常量，然后向外移动到每个连续的封闭模块（或类），直到找到在该范围内定义的常量。

在您的控制器中，您调用authorize。但是当authorize执行时，当前执行的代码是在Auth中。这就是查找常量的地方。如果 Auth 没有 USER_KEY，但封闭模块有，则将使用封闭模块。示例：

module Outer
  USER_KEY = 'outer_key'
  module Auth
     # code here can access USER_KEY without specifying "Outer::"
     # ...
  end
end

这种情况的一个特殊情况是顶级执行环境，它被视为属于类Object。

USER_KEY = 'top-level-key'
module Auth
  # code here can access the top-level USER_KEY (which is actually Object::USER_KEY)
  # ...
end

一个陷阱是使用作用域运算符 (::) 定义模块或类：

module Outer
  USER_KEY = 'outer_key'
end
module Outer::Auth
  # methods here won't be able to use USER_KEY,
  # because Outer isn't lexically enclosing Auth.
  # ...
end

请注意，常量的定义可能晚于方法的定义。查找仅在访问 USER_KEY 时发生，因此这也有效：

module Auth
  # don't define USER_KEY yet
  # ...
end

# you can't call authorize here or you'll get an uninitialized constant error

Auth::USER_KEY = 'user'

# now you can call authorize.

Answer 4

如果您的项目在 Rails 中，或者至少使用 ActiveSupport 模块，您可以显着减少必要的逻辑糖：

module Auth

  extend ActiveSupport::Concern

  included do
    # set a global default value
    unless self.const_defined?(:USER_KEY)
      self.const_set :USER_KEY, 'module_user'
    end
  end

end

class ApplicationController < ActionController::Base
  # set an application default value
  USER_KEY = "default_user"
  include Auth  
end

class SomeController < ApplicationController
  # set a value unique to a specific controller
  USER_KEY = "specific_user"
end

我很惊讶没有人建议这种方法，因为看到 OP 的场景如何驻留在一个轨道应用程序...

Answer 5

对于OP的问题，有一个比这里揭示的其他答案简单得多的解决方案：

module Foo
  THIS_CONST = 'foo'

  def show_const
    self.class::THIS_CONST
  end
end

class Bar
  include Foo

  THIS_CONST ='bar'
  def test_it
    show_const
  end
end

class Baz
  include Foo

  def test_it
    show_const
  end
end

2.3.1 :004 > r = Bar.new
 => #<Bar:0x000000008be2c8> 
2.3.1 :005 > r.test_it
 => "bar" 
2.3.1 :006 > z = Baz.new
 => #<Baz:0x000000008658a8> 
2.3.1 :007 > z.test_it
 => "foo" 

@james-a-rosen的答案给了我尝试这个的灵感。我不想走他的路，因为我有几个常量在多个类之间共享，每个常量都有不同的值，而且他的方法看起来需要大量输入。