在 Ruby 中，如何编写一个方法来显示任何对象的实例变量名称及其值

Question

给定 Ruby（on Rails）中的任何对象，我如何编写一个方法，以便它显示该对象的实例变量名称及其值，如下所示：（

@x: 1
@y: 2
@link_to_point: #<Point:0x10031b298 @y=20, @x=38>

更新： inspect 除了大对象之外，很难从 200 行输出中分解变量，就像在 Rails 中，当您在 request.inspect 或 self.inspect 中ActionView 对象）

我还希望能够将
打印到每个实例变量值的末尾，以便在网页上很好地打印它们。

现在的困难似乎是不是每个实例变量都有访问器，因此不能用 obj.send(var_name) 调用它

（var_name 删除了“@”，因此“@x”变成了“x”）

<更新：我想使用递归，它可以打印出更高级的版本：

#<Point:0x10031b462>
    @x: 1
    @y: 2
    @link_to_point: #<Point:0x10031b298>
        @x=38
        @y=20

Answer 1

我可能会这样写：

class Object
  def all_variables(root=true)
    vars = {}
    self.instance_variables.each do |var|
      ivar = self.instance_variable_get(var)
      vars[var] = [ivar, ivar.all_variables(false)]
    end
    root ? [self, vars] : vars
  end
end

def string_variables(vars, lb="\n", indent="\t", current_indent="")
  out             = "#{vars[0].inspect}#{lb}"
  current_indent += indent
  out            += vars[1].map do |var, ivar|
                      ivstr = string_variables(ivar, lb, indent, current_indent)
                      "#{current_indent}#{var}: #{ivstr}"
                    end.join
  return out
end

def inspect_variables(obj, lb="\n", indent="\t", current_indent="")
  string_variables(obj.all_variables, lb, indent, current_indent)
end

Object#all_variables 方法生成一个数组，其中包含 (0) 给定对象和 (1) 将实例变量名称映射到包含 (0) 实例变量的数组的哈希值，以及(1) 哈希映射......因此，它为您提供了一个很好的递归结构。 string_variables 函数可以很好地打印出该哈希值； inspect_variables 只是一个方便的包装器。因此，printspect_variables(foo)为您提供了一个换行符分隔的选项，而printinspect_variables(foo, "
gt;\n")为您提供了版本带有 HTML 换行符。如果您想指定缩进，也可以这样做： printspectr_variables(foo, "\n", "|---") 生成（无用的）人造树格式而不是制表符基于-的缩进。

应该有一种明智的方法来编写一个 each_variable 函数，您可以向该函数提供回调（不必分配中间存储）；如果我想到什么，我会编辑这个答案以包含它。 编辑1：我想到了一些事情。

这是另一种编写方式，我认为这种方式稍微好一些：

class Object
  def each_variable(name=nil, depth=0, parent=nil, &block)
    yield name, self, depth, parent
    self.instance_variables.each do |var|
      self.instance_variable_get(var).each_variable(var, depth+1, self, &block)
    end
  end
end

def inspect_variables(obj, nl="\n", indent="\t", sep=': ')
  out = ''
  obj.each_variable do |name, var, depth, _parent|
    out += [indent*depth, name, name ? sep : '', var.inspect, nl].join
  end
  return out
end

Object#each_variable 方法采用许多可选参数，这些参数不是设计为由用户指定的；相反，递归使用它们来维护状态。给定的块被传递 (a) 实例变量的名称，如果变量是递归的根，则传递 nil ； (b) 变量； (c) 递归下降的深度； (d) 当前变量的父级，如果所述变量是递归的根，则为 nil。递归是深度优先的。 inspect_variables 函数使用它来构建一个字符串。 obj 参数是要迭代的对象； nl 是行分隔符； indent 是要在每个级别应用的缩进；和 sep 分隔名称和值。

编辑2：这并没有真正为您的问题的答案添加任何内容，但是：只是为了证明我们在重新实现中没有丢失任何内容，这里是 all_variables 就 each_variables 而言。

def all_variables(obj)
  cur_depth = 0
  root      = [obj, {}]

  tree      = root
  parents   = []
  prev      = root

  obj.each_variable do |name, var, depth, _parent|
    next unless name

    case depth <=> cur_depth
      when -1 # We've gone back up
        tree = parents.pop(cur_depth - depth)[0]
      when +1 # We've gone down
        parents << tree
        tree = prev
      else # We're at the same level
        # Do nothing
    end

    cur_depth            = depth
    prev = tree[1][name] = [var, {}]
  end

  return root
end

我觉得它应该更短，但那可能不可能；因为我们现在没有递归，所以我们必须显式维护堆栈（在 parents 中）。但这是可能的，因此 each_variable 方法也同样有效（而且我认为它更好一点）。

Answer 2

我明白了... Antal 必须在这里给出高级版本...

简短版本可能是：

def p_each(obj)
  obj.instance_variables.each do |v|
    puts "#{v}: #{obj.instance_variable_get(v)}\n"
  end
  nil
end

或将其作为字符串返回：

def sp_each(obj)
  s = ""
  obj.instance_variables.each do |v|
    s += "#{v}: #{obj.instance_variable_get(v)}\n"
  end
  s
end

或更短：

def sp_each(obj)
  obj.instance_variables.map {|v| "#{v}: #{obj.instance_variable_get(v)}\n"}.join
end

Answer 3

这是一个简单的 我为另一个问题编写的 JSON 发射器：

class Object
  def inspect!(indent=0)
    return inspect if instance_variables.empty?
    "#<#{self.class}:0x#{object_id.to_s(16)}\n#{'  ' * indent+=1}#{
      instance_variables.map {|var|
        "#{var}: #{instance_variable_get(var).inspect!(indent)}"
      }.join("\n#{'  ' * indent}")
    }\n#{'  ' * indent-=1}>"
  end
end

class Array
  def inspect!(indent=0)
    return '[]' if empty?
    "[\n#{'  ' * indent+=1}#{
      map {|el| el.inspect!(indent) }.join(",\n#{'  ' * indent}")
    }\n#{'  ' * indent-=1}]"
  end
end

class Hash
  def inspect!(indent=0)
    return '{}' if empty?
    "{\n#{'  ' * indent+=1}#{
      map {|k, v|
        "#{k.inspect!(indent)} => #{v.inspect!(indent)}"
      }.join(",\n#{'  ' * indent}")
    }\n#{'  ' * indent-=1}}"
  end
end

这就是所有的魔力，真的。现在，我们只需要对某些类型进行一些简单的默认设置，在这些类型中，全面检查实际上没有意义（nil、false、true、数字等）：

module InspectBang
  def inspect!(indent=0)
    inspect
  end
end

[Numeric, Symbol, NilClass, TrueClass, FalseClass, String].each do |klass|
  klass.send :include, InspectBang
end

Answer 4

像这样？

# Get the instance variables of an object
d = Date.new
d.instance_variables.each{|i| puts i + "<br />"}

有关instance_variables的Ruby文档。

这个概念通常被称为“内省”（审视自己）。