Question

鉴于我有这个哈希：

 h = { a: 'a', b: 'b', c: { d: 'd', e: 'e'} }

我转换为OpenStruct：

o = OpenStruct.new(h)
 => #<OpenStruct a="a", b="b", c={:d=>"d", :e=>"e"}> 
o.a
 => "a" 
o.b
 => "b" 
o.c
 => {:d=>"d", :e=>"e"} 
2.1.2 :006 > o.c.d
NoMethodError: undefined method `d' for {:d=>"d", :e=>"e"}:Hash

我希望所有嵌套键都是方法。所以我可以这样访问d：

o.c.d
=> "d"

我怎样才能做到这一点？

Answer 1

你可以修补Hash类

class Hash
  def to_o
    JSON.parse to_json, object_class: OpenStruct
  end
end

然后你可以说

h = { a: 'a', b: 'b', c: { d: 'd', e: 'e'} }
o = h.to_o
o.c.d # => 'd'

请参阅YouTube Developer Policy。

Answer 2

我提出了这个解决方案：

h = { a: 'a', b: 'b', c: { d: 'd', e: 'e'} }
json = h.to_json
=> "{\"a\":\"a\",\"b\":\"b\",\"c\":{\"d\":\"d\",\"e\":\"e\"}}" 
object = JSON.parse(json, object_class:OpenStruct)
object.c.d
 => "d"

为了实现这一点，我必须做一个额外的步骤：将其转换为json。

Answer 3

我亲自使用recursive-open-struct宝石 - 然后就像RecursiveOpenStruct.new(<nested_hash>)一样简单

但是为了递归练习，我会告诉你一个新的解决方案：

require 'ostruct'

def to_recursive_ostruct(hash)
  OpenStruct.new(hash.each_with_object({}) do |(key, val), memo|
    memo[key] = val.is_a?(Hash) ? to_recursive_ostruct(val) : val
  end)
end

puts to_recursive_ostruct(a: { b: 1}).a.b
# => 1

修改的

这比基于JSON的解决方案更好的原因是因为转换为JSON时可能会丢失一些数据。例如，如果将Time对象转换为JSON然后解析它，它将是一个字符串。还有很多其他的例子：

class Foo; end
JSON.parse({obj: Foo.new}.to_json)["obj"]
# => "#<Foo:0x00007fc8720198b0>"

是的......不是超级有用的。你已经完全失去了对实际实例的引用。

Answer 4

这是一种递归解决方案，可避免将哈希转换为json：

def to_o(obj)
  if obj.is_a?(Hash)
    return OpenStruct.new(obj.map{ |key, val| [ key, to_o(val) ] }.to_h)
  elsif obj.is_a?(Array)
    return obj.map{ |o| to_o(o) }
  else # Assumed to be a primitive value
    return obj
  end
end

Answer 5

我的解决方案基于max pleaner's answer，类似于Xavi's answer：

require 'ostruct'

def initialize_open_struct_deeply(value)
  case value
  when Hash
    OpenStruct.new(value.transform_values { |hash_value| send __method__, hash_value })
  when Array
    value.map { |element| send __method__, element }
  else
    value
  end
end

Answer 6

这是覆盖初始化程序的一种方法，以便您可以执行 OpenStruct.new({ a: "b", c: { d: "e", f: ["g", "h", "i"] }})。

此外，这个类是在你require 'json'时包含的，所以一定要在require之后做这个补丁。

class OpenStruct
  def initialize(hash = nil)
    @table = {}
    if hash
      hash.each_pair do |k, v|
        self[k] = v.is_a?(Hash) ? OpenStruct.new(v) : v
      end
    end
  end

  def keys
    @table.keys.map{|k| k.to_s}
  end
end

递归地将Hash转换为OpenStruct

6 个答案: