在ruby中访问嵌套哈希的元素[重复]

Question

这个问题在这里已有答案：

我正在使用ruby编写的一个小实用程序，它广泛使用嵌套哈希。目前，我正在检查对嵌套哈希元素的访问，如下所示：

structure = { :a => { :b => 'foo' }}

# I want structure[:a][:b]

value = nil

if structure.has_key?(:a) && structure[:a].has_key?(:b) then
  value = structure[:a][:b]
end

有一个更好的方法吗？我想能够说：

value = structure[:a][:b]

并获得nil如果：a不是structure的关键等。

Answer 1

传统上，你真的必须做这样的事情：

structure[:a] && structure[:a][:b]

但是，Ruby 2.3添加了一种方法Hash#dig，使这种方式更加优雅：

structure.dig :a, :b # nil if it misses anywhere along the way

有一个名为ruby_dig的宝石会为你补贴。

Answer 2

哈希的这个猴子补丁函数应该是最简单的（至少对我而言）。它也不会改变结构，即将nil改为{}。即使你是从原始资源中读取一棵树，它仍然适用。 JSON。它也不需要在进行或解析字符串时生成空哈希对象。 rescue nil对我来说实际上是一个很好的解决方案，因为我足够勇敢以获得如此低的风险，但我发现它基本上有性能上的缺点。

class ::Hash
  def recurse(*keys)
    v = self[keys.shift]
    while keys.length > 0
      return nil if not v.is_a? Hash
      v = v[keys.shift]
    end
    v
  end
end

例：

> structure = { :a => { :b => 'foo' }}
=> {:a=>{:b=>"foo"}}

> structure.recurse(:a, :b)
=> "foo"

> structure.recurse(:a, :x)
=> nil

还有什么好处是你可以用它来玩游戏：

> keys = [:a, :b]
=> [:a, :b]

> structure.recurse(*keys)
=> "foo"

> structure.recurse(*keys, :x1, :x2)
=> nil

Answer 3

你可以使用andand gem，但我对它越来越警惕了：

>> structure = { :a => { :b => 'foo' }} #=> {:a=>{:b=>"foo"}}
>> require 'andand' #=> true
>> structure[:a].andand[:b] #=> "foo"
>> structure[:c].andand[:b] #=> nil

Answer 4

有可爱但错误的方法来做到这一点。这是猴子补丁NilClass添加一个返回[]的nil方法。我说这是错误的方法，因为你不知道其他软件可能有什么不同版本，或者未来版本的Ruby中的行为改变可以被这个打破。

更好的方法是创建一个像nil一样工作的新对象，但支持这种行为。使此新对象成为哈希的默认返回值。然后它就会起作用。

或者，您可以创建一个简单的“嵌套查找”函数，您可以将哈希和键传递给它，它按顺序遍历哈希值，并在可能的情况下突破。

我个人更喜欢后两种方法中的一种。虽然我认为如果将第一个集成到Ruby语言中会很可爱。（但猴子修补是一个坏主意。不要这样做。特别是不要证明你是一个很酷的黑客。）

Answer 5

不是我会这样做，但你可以在NilClass#[] Monkeypatch：

> structure = { :a => { :b => 'foo' }}
#=> {:a=>{:b=>"foo"}}

> structure[:x][:y]
NoMethodError: undefined method `[]' for nil:NilClass
        from (irb):2
        from C:/Ruby/bin/irb:12:in `<main>'

> class NilClass; def [](*a); end; end
#=> nil

> structure[:x][:y]
#=> nil

> structure[:a][:y]
#=> nil

> structure[:a][:b]
#=> "foo"

使用@ DigitalRoss的答案。是的，它打字更多，但那是因为它更安全。

Answer 6

就我而言，我需要一个二维矩阵，其中每个单元格都是一个项目列表。

我发现这种技术似乎有效。它可能适用于OP：

$all = Hash.new()

def $all.[](k)
  v = fetch(k, nil)
  return v if v

  h = Hash.new()
  def h.[](k2)
    v = fetch(k2, nil)
    return v if v
    list = Array.new()
    store(k2, list)
    return list
  end

  store(k, h)
  return h
end

$all['g1-a']['g2-a'] << '1'
$all['g1-a']['g2-a'] << '2'

$all['g1-a']['g2-a'] << '3'
$all['g1-a']['g2-b'] << '4'

$all['g1-b']['g2-a'] << '5'
$all['g1-b']['g2-c'] << '6'

$all.keys.each do |group1|
  $all[group1].keys.each do |group2|
    $all[group1][group2].each do |item|
      puts "#{group1} #{group2} #{item}"
    end
  end
end

输出是：

$ ruby -v && ruby t.rb
ruby 1.9.2p0 (2010-08-18 revision 29036) [x86_64-linux]
g1-a g2-a 1
g1-a g2-a 2
g1-a g2-a 3
g1-a g2-b 4
g1-b g2-a 5
g1-b g2-c 6

Answer 7

我目前正在尝试这个：

# --------------------------------------------------------------------
# System so that we chain methods together without worrying about nil
# values (a la Objective-c).
# Example:
#   params[:foo].try?[:bar]
#
class Object
  # Returns self, unless NilClass (see below)
  def try?
    self
  end
end  
class NilClass
  class MethodMissingSink
    include Singleton
    def method_missing(meth, *args, &block)
    end
  end
  def try?
    MethodMissingSink.instance
  end
end

我知道反对try的论点，但在研究诸如params这样的事情时它很有用。

Answer 8

Ruby 2.3.0在a new method called dig和Hash上引入了Array，完全解决了这个问题。

value = structure.dig(:a, :b)

如果在任何级别缺少密钥，它将返回nil。

如果您使用的是早于2.3的Ruby版本，则可以使用ruby_dig gem或自行实现：

module RubyDig
  def dig(key, *rest)
    if value = (self[key] rescue nil)
      if rest.empty?
        value
      elsif value.respond_to?(:dig)
    value.dig(*rest)
      end
    end
  end
end

if RUBY_VERSION < '2.3'
  Array.send(:include, RubyDig)
  Hash.send(:include, RubyDig)
end

Answer 9

这些天我通常这样做的方式是：

h = Hash.new { |h,k| h[k] = {} }

这将为您提供一个哈希，创建一个新哈希作为缺失键的条目，但返回第二级键的nil：

h['foo'] -> {}
h['foo']['bar'] -> nil

您可以嵌套此项以添加可以通过这种方式解决的多个图层：

h = Hash.new { |h, k| h[k] = Hash.new { |hh, kk| hh[kk] = {} } }

h['bar'] -> {}
h['tar']['zar'] -> {}
h['scar']['far']['mar'] -> nil

您还可以使用default_proc方法无限链接：

h = Hash.new { |h, k| h[k] = Hash.new(&h.default_proc) }

h['bar'] -> {}
h['tar']['star']['par'] -> {}

上面的代码创建了一个哈希，其默认proc创建一个具有相同默认proc的新哈希。因此，在查找未见密钥时创建的哈希值将具有相同的默认行为。

编辑：更多细节

Ruby哈希允许您控制在为新键进行查找时如何创建默认值。指定时，此行为将封装为Proc对象，并且可通过default_proc和default_proc=方法访问。也可以通过将块传递给Hash.new来指定默认proc。

让我们把这段代码打破一点。这不是惯用的红宝石，但更容易将其划分为多行：

1. recursive_hash = Hash.new do |h, k|
2.   h[k] = Hash.new(&h.default_proc)
3. end

第1行声明一个变量recursive_hash是一个新的Hash并开始一个块为recursive_hash的default_proc。该块传递两个对象：h，它是正在执行键查找的Hash实例，k，正在查找的键。

第2行将散列中的默认值设置为新的Hash实例。此哈希的默认行为是通过传递从查找发生的哈希的Proc创建的default_proc来提供的;即，块本身正在定义的默认proc。

以下是IRB会话的示例：

irb(main):011:0> recursive_hash = Hash.new do |h,k|
irb(main):012:1* h[k] = Hash.new(&h.default_proc)
irb(main):013:1> end
=> {}
irb(main):014:0> recursive_hash[:foo]
=> {}
irb(main):015:0> recursive_hash
=> {:foo=>{}}

当recursive_hash[:foo]的哈希创建时，它的default_proc由recursive_hash的default_proc提供。这有两个影响：

recursive_hash[:foo]的默认行为与recursive_hash相同。
recursive_hash[:foo]的default_proc创建的哈希的默认行为与recursive_hash相同。

因此，继续IRB，我们得到以下内容：

irb(main):016:0> recursive_hash[:foo][:bar]
=> {}
irb(main):017:0> recursive_hash
=> {:foo=>{:bar=>{}}}
irb(main):018:0> recursive_hash[:foo][:bar][:zap]
=> {}
irb(main):019:0> recursive_hash
=> {:foo=>{:bar=>{:zap=>{}}}}

Answer 10

我为此制作了rubygem。试试vine。

安装：

gem install vine

用法：

hash.access("a.b.c")

Answer 11

我认为最可读的解决方案之一是使用Hashie：

require 'hashie'
myhash = Hashie::Mash.new({foo: {bar: "blah" }})

myhash.foo.bar
=> "blah"    

myhash.foo?
=> true

# use "underscore dot" for multi-level testing
myhash.foo_.bar?
=> true
myhash.foo_.huh_.what?
=> false

Answer 12

3
投票

value = structure[:a][:b] rescue nil

Answer 13

解决方案1

我之前在我的问题中建议过：

class NilClass; def to_hash; {} end end

Hash#to_hash已经定义，并返回自我。然后你可以这样做：

value = structure[:a].to_hash[:b]

to_hash确保在上一次密钥搜索失败时获得空哈希。

溶液2

这个解决方案在精神上类似于mu太短的答案，因为它使用了一个子类，但仍然有些不同。如果某个键没有值，它不会使用默认值，而是创建一个空哈希值，这样就不会出现DigitalRoss答案所具有的混淆问题，正如之所指出的那样。亩太短了。

class NilFreeHash < Hash
  def [] key; key?(key) ? super(key) : self[key] = NilFreeHash.new end
end

structure = NilFreeHash.new
structure[:a][:b] = 3
p strucrture[:a][:b] # => 3

不过，它不同于问题中给出的规范。当给出未定义的键时，它将返回nil的空哈希表达式。

p structure[:c] # => {}

如果从头开始构建此NilFreeHash的实例并分配键值，它将起作用，但如果要将哈希转换为此类的实例，则可能存在问题。

Answer 14

您可以使用额外的可变方法构建一个Hash子类，以便在整个过程中一直进行适当的检查。像这样的东西（当然有更好的名字）：

class Thing < Hash
    def find(*path)
        path.inject(self) { |h, x| return nil if(!h.is_a?(Thing) || h[x].nil?); h[x] }
    end
end

然后只使用Things而不是哈希：

>> x = Thing.new
=> {}
>> x[:a] = Thing.new
=> {}
>> x[:a][:b] = 'k'
=> "k"
>> x.find(:a)
=> {:b=>"k"}
>> x.find(:a, :b)
=> "k"
>> x.find(:a, :b, :c)
=> nil
>> x.find(:a, :c, :d)
=> nil

Answer 15

require 'xkeys'

structure = {}.extend XKeys::Hash
structure[:a, :b] # nil
structure[:a, :b, :else => 0] # 0 (contextual default)
structure[:a] # nil, even after above
structure[:a, :b] = 'foo'
structure[:a, :b] # foo

在ruby中访问嵌套哈希的元素[重复]

问题描述投票：28回答：15

15个回答

最新问题

在ruby中访问嵌套哈希的元素[重复]

问题描述 投票：28回答：15

15个回答

最新问题

问题描述投票：28回答：15