类似红宝石的物体

Question

如何在 ruby 中创建一个对象，该对象在类似于 nil 的逻辑表达式中将被计算为 false？

我的目的是在其他对象上启用嵌套调用，其中链的一半通常会nil值，但允许所有调用继续 - 返回我的类似 nil 的对象而不是nil本身。该对象将返回自身以响应它不知道如何处理的任何收到的消息，我预计我需要实现一些覆盖方法，例如 nil? .

例如：

fizz.buzz.foo.bar

如果 fizz 的 buzz 属性不可用，我将返回我的类似 nil 的对象，它将接受调用一直到bar返回自身。最终，上面的陈述应该评估为假。

编辑：

基于下面的所有精彩答案，我提出了以下内容：

class NilClass
  attr_accessor :forgiving
  def method_missing(name, *args, &block)
    return self if @forgiving
    super
  end
  def forgive
    @forgiving = true
    yield if block_given?
    @forgiving = false
  end
end

这允许一些卑鄙的技巧，如下所示：

nil.forgiving {
    hash = {}
    value = hash[:key].i.dont.care.that.you.dont.exist
    if value.nil?
        # great, we found out without checking all its parents too
    else
        # got the value without checking its parents, yaldi
    end
}

显然，您可以将此块透明地包装在某些函数调用/类/模块/任何地方中。

Answer 1

这是一个很长的答案，其中包含一堆有关如何解决问题的想法和代码示例。

try

Rails有一个尝试方法，可以让你像这样编程。这是它的实现方式：

class Object
  def try(*args, &b)
    __send__(*a, &b)
  end
end
class NilClass        # NilClass is the class of the nil singleton object
  def try(*args)
    nil
  end
end

你可以像这样用它编程：

fizz.try(:buzz).try(:foo).try(:bar)

您可以想象修改它以稍微不同的工作方式以支持更优雅的 API：

class Object
  def try(*args)
    if args.length > 0
      method = args.shift         # get the first method
      __send__(method).try(*args) # Call `try` recursively on the result method
    else
      self                        # No more methods in chain return result
    end
  end
end
# And keep NilClass same as above

然后你可以做：

fizz.try(:buzz, :foo, :bar)

andand

andand 使用了一种更邪恶的技术，破解了你不能直接实例化 NilClass 子类的事实：

class Object
  def andand
    if self
      self
    else               # this branch is chosen if `self.nil? or self == false`
      Mock.new(self)   # might want to modify if you have useful methods on false
    end
  end
end
class Mock < BasicObject
  def initialize(me)
    super()
    @me = me
  end
  def method_missing(*args)  # if any method is called return the original object
    @me
  end
end

这允许您以这种方式编程：

fizz.andand.buzz.andand.foo.andand.bar

结合一些花哨的重写

同样，您可以扩展此技术：

class Object
  def method_missing(m, *args, &blk)        # `m` is the name of the method
    if m[0] == '_' and respond_to? m[1..-1] # if it starts with '_' and the object
      Mock.new(self.send(m[1..-1]))         # responds to the rest wrap it.
    else                                    # otherwise throw exception or use
      super                                 # object specific method_missing
    end
  end
end
class Mock < BasicObject
  def initialize(me)
    super()
    @me = me
  end
  def method_missing(m, *args, &blk)
    if m[-1] == '_'  # If method ends with '_'
      # If @me isn't nil call m without final '_' and return its result.
      # If @me is nil then return `nil`.
      @me.send(m[0...-1], *args, &blk) if @me 
    else 
      @me = @me.send(m, *args, &blk) if @me # Otherwise call method on `@me` and
      self                                  # store result then return mock.
    end
  end
end

解释一下发生了什么：当你调用一个下划线的方法时，你会触发模拟模式，_meth的结果会自动包装在Mock对象中。每当您在该模拟上调用方法时，它都会检查它是否没有nil然后将您的方法转发到该对象(此处存储在 @me 变量中(。然后，模拟将原始对象替换为函数调用的结果。当您调用meth_时，它将结束模拟模式并返回 meth 的实际返回值。

这允许像这样的 api(我使用了下划线，但你可以使用任何东西(：

fizz._buzz.foo.bum.yum.bar_

残酷的猴子修补方法

这真的很讨厌，但它允许一个优雅的 API，并且不一定会搞砸整个应用程序中的错误报告：

class NilClass
  attr_accessor :complain
  def method_missing(*args)
    if @complain
      super
    else
      self
    end
  end
end
nil.complain = true

像这样使用：

nil.complain = false
fizz.buzz.foo.bar
nil.complain = true

Answer 2

据我所知，没有真正简单的方法可以做到这一点。在 Ruby 社区中已经做了一些工作来实现您正在谈论的功能;您可能想看看：

• 安丹宝石
• Rails的try方法

andand gem 是这样用的：

require 'andand'
...
fizz.buzz.andand.foo.andand.bar

Answer 3

您可以修改NilClass类以使用method_missing()来响应任何尚未定义的方法。

> class NilClass
>   def method_missing(name)
>     return self
>   end
> end
=> nil
> if nil:
*   puts "true"
> end
=> nil
> nil.foo.bar.baz
=> nil

Answer 4

有一个原则叫做得墨忒耳定律[1]，它表明你试图做的不是好的做法，因为你的对象不一定知道太多关于其他对象的关系。

但是，我们都这样做：-(

在简单的情况下，我倾向于将属性链接委托给检查是否存在的方法：

class Fizz
  def buzz_foo_bar
    self.buzz.foo.bar if buzz && buzz.foo && buzz.foo.bar
  end
end

所以我现在可以打电话给fizz.buzz_foo_bar知道我不会得到例外。

但是我也有一段代码(在工作中，直到下周我才能抓住它(，它处理方法缺失并查找下划线和测试反映的关联，以查看它们是否响应链的其余部分。这意味着我现在不必编写委托方法等 - 只需包含method_missing补丁：

module ActiveRecord
  class Base
    def children_names
      association_names=self.class.reflect_on_all_associations.find_all{|x| x.instance_variable_get("@macro")==:belongs_to}
      association_names.map{|x| x.instance_variable_get("@name").to_s} | association_names.map{|x| x.instance_variable_get("@name").to_s.gsub(/^#{self.class.name.underscore}_/,'')}
    end
    def reflected_children_regex
      Regexp.new("^(" << children_names.join('|') << ")_(.*)")
    end
    def method_missing(method_id, *args, &block)
      begin
        super
      rescue NoMethodError, NameError
        if match_data=method_id.to_s.match(reflected_children_regex)
          association_name=self.methods.include?(match_data[1]) ? match_data[1] : "#{self.class.name.underscore}_#{match_data[1]}"
          if association=send(association_name)
            association.send(match_data[2],*args,&block)
          end
        else
          raise
        end
      end
    end
  end
end

[1] http://en.wikipedia.org/wiki/Law_of_Demeter