Ruby 递归地将哈希转换为OpenStruct

考虑到我有这个散列：

 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

---

我如何才能做到这一点？

我提出了以下解决方案：

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" 

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。

我个人使用的是

递归开放结构

gem-然后它就像

RecursiveOpenStruct.new（）一样简单。

但为了进行递归实践，我将向您展示一个新的解决方案：

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" 

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时可能会丢失一些数据。例如，如果您将时间对象转换为JSON，然后对其进行解析，它将是一个字符串。这方面还有许多其他例子：

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

Foo类；结束
parse（{obj:Foo.new}.to_JSON）[“obj”]
# => "#"

---

嗯。。。不是很有用。您已经完全丢失了对实际实例的引用。

您可以对

哈希类进行猴子补丁

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'

请参阅。
这里有一个避免将哈希转换为json的递归解决方案：

def至_o（obj）
如果对象是a？（散列）
返回OpenStruct.new（对象映射{| key，val{key，to_o（val）]}.to_h）
elsif对象是_？（数组）
返回对象映射{o| to_o（o）}
否则，假定为原始值
返回obj
结束
结束
我的解决方案，基于并类似于：

需要“ostruct”
def initialize_open_struct_deep（值）
案例价值
当散列
OpenStruct.new（value.transform_values{| hash_value | send u方法uu，hash_值}）
当数组
value.map{|元素|发送uuu方法uuu，元素}
其他的
价值
结束
结束
这里有一种方法可以覆盖初始值设定项，这样您就可以执行OpenStruct.new（{a:“b”，c:{d:“e”，f:[“g”，“h”，“i”]}}）

此外，当您

需要“json”

时，会包含此类，因此请确保在

require

之后执行此修补程序

类OpenStruct
def初始化（散列=nil）
@表={}
如果散列
hash.u每对do | k，v|
self[k]=v.is_a？（散列）？OpenStruct.new（v）：v
结束
结束
结束
def键
@表.键.映射{| k | k.to_s}
结束
结束

凌乱但实用。但是有更好的方法。依赖关系？Openstruct和Json是标准库的一部分。我遇到的一个不同之处是我必须调用

object.table.c.d

。如果你喜欢OpenStruct，你会喜欢的。@donato我知道这是一个老问题。但请检查我的答案，让我知道这是否有帮助。我已经为openstruct创建了一个PR，将其包含在库中。如果你认为它会帮助像你这样的人，请支持它。使用Ruby已经超过10年了，我仍然对它的优雅感到惊讶。虽然它应该可以解决这个问题，但这个过程有一些副作用，比如它会改变项目中所有地方的默认

散列
行为，这可能会在未来几天造成无法预料的问题。因此，我宁愿选择max_pleaner或Donato
JSON.parse（h.to_JSON，object\u class:OpenStruct）
，它似乎可以解决问题，而且没有副作用。仅供参考，这只适用于简单的值。当我将此方法应用于更复杂的对象（例如BigDecimal或自定义ActiveRecord对象）时，我遇到了一些问题。我使用了您的答案，并且能够很好地处理哈希，如果在数组值中包含哈希，例如{a:'a'，b:'b'，c:[{d:'d'，e:'e'}}，那么我可以执行c.d=>'d'谢谢：）@aldrien.h如果您有
{c:[{d:'d'}}d'}
为什么要使用
c.d
？如果数组中有多个散列，那该怎么办呢？
JSON.parse
的答案更灵活、更优雅。@TončiD。事实并非如此。问题是不是所有的东西都可以转换成JSON并保持其相同的Ruby类。例如
JSON.parse（{now:Time.now}.to_JSON）[“now”].class==String
。。。
Time.now
在解析/解析它时不再是
Time
对象。@maxpleaner在
memo[key]=…
下面添加这一行将处理数组：
memo[key]=val.map{v | v.is|u a？（散列）{u递归_ostruct（v）：v}如果val.is_？（数组）
因为每个带有_对象的{u都不推荐使用，对我来说，这是最好的解决办法