（不是#dig！）如何确定深度嵌套的Ruby Hash中的键*存在*？

Question

有没有一种“简单”的方法，除了手写Hash#dig 执行的那种嵌套哈希/数组遍历，我可以确定一个键是否存在于深度嵌套的哈希中？另一种询问方式是说“确定是否分配了任何值”。

没有分配任何内容的 Hash 与明确分配了 nil 之间存在差异 - 特别是如果 Hash 是使用与 nil 不同的缺失键默认值构造的！

h = { :one => { :two => nil }}
h.dig(:one, :two).nil? # => true; but :two *is* present; it is assigned "nil". 
h[:one].key?(:two) # => true, because the key exists

h = { :one => {}}
h.dig(:one, :two).nil? # => true; :two *is not* present; no value is assigned.
h[:one].key?(:two) # => FALSE, because the key does not exist

Answer 1

如果您纯粹是检查密钥是否存在，您可以将dig 和key? 结合使用。在您的一系列按键中的最后一个或最后一个按键上使用 key?。

input_hash = {
  hello: {
    world: {
      existing: nil,
    }
  }
}

# Used !! to make the result boolean

!!input_hash.dig(:hello, :world)&.key?(:existing) # => true
!!input_hash.dig(:hello, :world)&.key?(:not_existing) # => false
!!input_hash.dig(:hello, :universe)&.has_key?(:not_existing) # => false

Answer 2

受您的核心扩展建议的启发，我稍微更新了实现以更好地模仿#dig

• 需要 1+ 个参数
• 如果挖掘没有返回nil，则引发TypeError，生成的对象不会响应dig?，并且还有其他参数要“挖掘”

module Diggable
  def dig?(arg,*args)
    return self.member?(arg) if args.empty?
    if val = self[arg] and val.respond_to?(:dig?) 
      val.dig?(*args)
    else
     val.nil? ? false : raise(TypeError, "#{val.class} does not have a #dig? method")
    end
  end
end

[Hash,Struct,Array].each { |klass| klass.send(:include,Diggable) }

class Array
  def dig?(arg,*args)
    return arg.abs < self.size if args.empty?
    super
  end
end

if defined?(OpenStruct)
  class OpenStruct
    def dig?(arg,*args)
      self.to_h.dig?(arg,*args)
    end
  end
end

用法

Foo = Struct.new(:a)

hash = {:one=>1, :two=>[1, 2, 3], :three=>[{:one=>1, :two=>2}, "hello", Foo.new([1,2,3]), {:one=>{:two=>{:three=>3}}}]}

hash.dig? #=> ArgumentError
hash.dig?(:one) #=> true
hash.dig?(:two, 0) #=> true
hash.dig?(:none) #=> false
hash.dig?(:none, 0) #=> false
hash.dig?(:two, -1) #=> true
hash.dig?(:two, 10) #=> false
hash.dig?(:three, 0, :two) #=> true
hash.dig?(:three, 0, :none) #=> false
hash.dig?(:three, 2, :a) #=> true
hash.dig?(:three, 3, :one, :two, :three, :f) #=> TypeError

Example

Answer 3

作为参考 - 采取不寻常的步骤来回答我自己的问题 ;-) - 如果我只是想写很多 Ruby，这是我可以解决这个问题的几种方法之一。

def dig?(obj, *args)
  arg = args.shift()

  return case obj
    when Array
      if args.empty?
        arg >= 0 && arg <= obj.size
      else
        dig?(obj[arg], *args)
      end
    when Hash
      if args.empty?
        obj.key?(arg)
      else
        dig?(obj[arg], *args)
      end
    when nil
      false
    else
      raise ArgumentError
  end
end

当然，如果您更喜欢核心扩展而不是显式方法，也可以打开 Array 和 Hash 之类的类并将#dig? 添加到这些类中：

class Hash
  def dig?(*args)
    arg = args.shift()

    if args.empty?
      self.key?(arg)
    else
      self[arg]&.dig?(*args) || false
    end
  end
end

class Array
  def dig?(*args)
    arg = args.shift()

    if args.empty?
      arg >= 0 && arg <= self.size
    else
      self[arg]&.dig?(*args) || false
    end
  end
end

...如果#dig? 参数导致非哈希/数组节点，则将引发NoMethodError 而不是ArgumentError。

显然，可以将它们压缩成更巧妙/优雅的解决方案，使用更少的行，但以上的好处是恕我直言，非常容易阅读。

不过，在原始问题的范围内，希望更多地依赖于 Ruby 开箱即用的任何东西。我们早就集体承认没有单一方法的解决方案，但the answer from @AmazingRein 通过重用#dig 来避免递归。我们可以修改如下：

def dig?(obj, *args)
  last_arg = args.pop()
  obj      = obj.dig(*args) unless args.empty?

  return case obj
    when Array
      last_arg >= 0 && last_arg <= obj.size
    when Hash
      obj.key?(last_arg)
    when nil
      false
    else
      raise ArgumentError
  end
end

...考虑到所有因素，这还不错。

# Example test...

hash = {:one=>1, :two=>[1, 2, 3], :three=>[{:one=>1, :two=>2}, "hello", {:one=>{:two=>{:three=>3}}}]}

puts dig?(hash, :one)
puts dig?(hash, :two, 0)
puts dig?(hash, :none)
puts dig?(hash, :none, 0)
puts dig?(hash, :two, -1)
puts dig?(hash, :two, 10)
puts dig?(hash, :three, 0, :two)
puts dig?(hash, :three, 0, :none)
puts dig?(hash, :three, 2, :one, :two, :three)
puts dig?(hash, :three, 2, :one, :two, :none)

Answer 4

这是一种简洁的方法，适用于嵌套的 Array 和 Hash（以及任何其他响应 fetch 的对象）。

def deep_fetch? obj, *argv
  argv.each do |arg|
    return false unless obj.respond_to? :fetch
    obj = obj.fetch(arg) { return false }
  end
  true
end

obj = { hello: [ nil, { world: nil } ] }
deep_fetch? obj, :hell # => false
deep_fetch? obj, :hello, 0 # => true
deep_fetch? obj, :hello, 2 # => false
deep_fetch? obj, :hello, 0, :world # => false
deep_fetch? obj, :hello, 1, :world # => true
deep_fetch? obj, :hello, :world
TypeError (no implicit conversion of Symbol into Integer)

之前的代码在访问具有非整数索引的数组元素时引发错误（就像Array#dig），这有时不是人们正在寻找的行为。以下代码在所有情况下都运行良好，但 rescue 不是一个好习惯：

def deep_fetch? obj, *argv
  argv.each { |arg| obj = obj.fetch(arg) } and true rescue false
end

obj = { hello: [ nil, { world: nil } ] }
deep_fetch? obj, :hell # => false
deep_fetch? obj, :hello, 0 # => true
deep_fetch? obj, :hello, 2 # => false
deep_fetch? obj, :hello, 0, :world # => false
deep_fetch? obj, :hello, 1, :world # => true
deep_fetch? obj, :hello, :world # => false