假设我有这个哈希表：
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"
我该如何实现这个目标？
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'
Hash行为，可能会在未来出现意想不到的问题。因此，我更倾向于使用max_pleaner或Donato提供的JSON.parse(h.to_json, object_class: OpenStruct)方法，它似乎可以在原地解决问题而没有副作用。 - Wasif Hossainh = { 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。
object.table.c.d。 - Tony Beninate就我个人而言，我使用recursive-open-struct宝石——这样做只需要RecursiveOpenStruct.new(<nested_hash>)就行了。
但是为了练习递归，我将向您展示一个崭新的解决方案：
require 'ostruct'
def to_recursive_ostruct(hash)
result = hash.each_with_object({}) do |(key, val), memo|
memo[key] = val.is_a?(Hash) ? to_recursive_ostruct(val) : val
end
OpenStruct.new(result)
end
puts to_recursive_ostruct(a: { b: 1}).a.b
# => 1
编辑
Weihang Jian在这里稍微改进了一下 https://dev59.com/yVgQ5IYBdhLWcg3wl1B3#69311716
def to_recursive_ostruct(hash)
hash.each_with_object(OpenStruct.new) do |(key, val), memo|
memo[key] = val.is_a?(Hash) ? to_recursive_ostruct(val) : val
end
end
另请参见https://dev59.com/yVgQ5IYBdhLWcg3wl1B3#63264908，其中展示了如何处理数组。
注意：
之所以这比基于JSON的解决方案更好，是因为将其转换为JSON时可能会丢失一些数据。例如，如果您将Time对象转换为JSON，然后解析它，它将变成一个字符串。还有许多其他类似的例子：
class Foo; end
JSON.parse({obj: Foo.new}.to_json)["obj"]
# => "#<Foo:0x00007fc8720198b0>"
是的...不是非常有用。你已经完全失去了对实际实例的引用。
JSON.parse 的答案更加灵活和优雅。 - Tonči D.JSON.parse({now: Time.now}.to_json)["now"].class == String... 当您解析/取消解析时，Time.now不再是一个Time对象。 - max pleanermemo[key] = ... 下面添加以下代码即可处理数组：memo[key] = val.map { |v| v.is_a?(Hash) ? to_recursive_ostruct(v) : v } if val.is_a?(Array) - Medardasdef 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
我基于max pleaner的回答并类似于Xavi的回答的解决方案：
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
我的解决方案比@max-pleaner的更加简洁快速。
我其实不知道为什么，但我不会实例化额外的哈希对象：
def dot_access(hash)
hash.each_with_object(OpenStruct.new) do |(key, value), struct|
struct[key] = value.is_a?(Hash) ? dot_access(value) : value
end
end
以下是供您参考的基准测试：
require 'ostruct'
def dot_access(hash)
hash.each_with_object(OpenStruct.new) do |(key, value), struct|
struct[key] = value.is_a?(Hash) ? dot_access(value) : value
end
end
def to_recursive_ostruct(hash)
result = hash.each_with_object({}) do |(key, val), memo|
memo[key] = val.is_a?(Hash) ? to_recursive_ostruct(val) : val
end
OpenStruct.new(result)
end
require 'benchmark/ips'
Benchmark.ips do |x|
hash = { a: 1, b: 2, c: { d: 3 } }
x.report('dot_access') { dot_access(hash) }
x.report('to_recursive_ostruct') { to_recursive_ostruct(hash) }
end
Warming up --------------------------------------
dot_access 4.843k i/100ms
to_recursive_ostruct 5.218k i/100ms
Calculating -------------------------------------
dot_access 51.976k (± 5.0%) i/s - 261.522k in 5.044482s
to_recursive_ostruct 50.122k (± 4.6%) i/s - 250.464k in 5.008116s
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
基于OpenStruct的转换方法在某些情况下效果很好，但在某些情况下则不行。例如，这里的其他答案都无法正确处理这些简单的哈希：
people = { person1: { display: { first: 'John' } } }
creds = { oauth: { trust: true }, basic: { trust: false } }
def add_indifferent_access!(hash)
hash.each_pair do |k, v|
hash.instance_variable_set("@#{k}", v.tap { |v| send(__method__, v) if v.is_a?(Hash) } )
hash.define_singleton_method(k, proc { hash.instance_variable_get("@#{k}") } )
end
end
那么
add_indifferent_access!(people)
people.person1.display.first # => 'John'
或者，如果您的上下文需要更内联的调用结构：
creds.yield_self(&method(:add_indifferent_access!)).oauth.trust # => true
或者，你可以混合使用它：
module HashExtension
def very_indifferent_access!
each_pair do |k, v|
instance_variable_set("@#{k}", v.tap { |v| v.extend(HashExtension) && v.send(__method__) if v.is_a?(Hash) } )
define_singleton_method(k, proc { self.instance_variable_get("@#{k}") } )
end
end
end
并且适用于各个哈希值：
favs = { song1: { title: 'John and Marsha', author: 'Stan Freberg' } }
favs.extend(HashExtension).very_indifferent_access!
favs.song1.title
class Hash
def with_very_indifferent_access!
each_pair do |k, v|
instance_variable_set("@#{k}", v.tap { |v| v.send(__method__) if v.is_a?(Hash) } )
define_singleton_method(k, proc { instance_variable_get("@#{k}") } )
end
end
end
# Note the omission of "v.extend(HashExtension)" vs. the mix-in variation.
其他答案中的评论表达了保留类类型的愿望。这个解决方案考虑到了这一点。
people = { person1: { created_at: Time.now } }
people.with_very_indifferent_access!
people.person1.created_at.class # => Time
如果你不介意猴子补丁 Hash 类，你可以这么做：
require 'ostruct'
module Structurizable
def each_pair(&block)
each do |k, v|
v = OpenStruct.new(v) if v.is_a? Hash
yield k, v
end
end
end
Hash.prepend Structurizable
people = { person1: { display: { first: 'John' } }, person2: { display: { last: 'Jingleheimer' } } }
puts OpenStruct.new(people).person1.display.first