如何根据提供的参数在 Ruby 中递归定义哈希？

Question

此代码片段填充 @options 哈希值。 values 是一个Array，其中包含零个或多个异构项。如果您使用 Hash 条目的参数调用 populate，它将使用您为每个条目指定的值来采用默认值。

def populate(*args)
  args.each do |a|
    values = nil
    if (a.kind_of? Hash)
      # Converts {:k => "v"} to `a = :k, values = "v"`
      a, values = a.to_a.first
    end

    @options[:"#{a}"] ||= values ||= {}
  end
end

我想要做的是更改populate，使其递归地填充@options。有一种特殊情况：如果要填充键的值是一个完全由（1）符号或（2）键为符号（或两者的某种组合）的哈希组成的数组，那么它们应该被视为子键而不是与该键关联的值，并且应该递归地重新应用用于评估原始填充参数的相同逻辑。

这有点难以用语言表达，所以我编写了一些测试用例。以下是一些测试用例以及之后 @options 的预期值：

populate :a
=> @options is {:a => {}}

populate :a => 42
=> @options is {:a => 42}

populate :a, :b, :c
=> @options is {:a => {}, :b => {}, :c => {}}

populate :a, :b => "apples", :c
=> @options is {:a => {}, :b => "apples", :c => {}}

populate :a => :b
=> @options is {:a => :b}

# Because [:b] is an Array consisting entirely of Symbols or
# Hashes whose keys are Symbols, we assume that :b is a subkey
# of @options[:a], rather than the value for @options[:a].
populate :a => [:b]
=> @options is {:a => {:b => {}}}

populate :a => [:b, :c => :d]
=> @options is {:a => {:b => {}, :c => :d}}

populate :a => [:a, :b, :c]
=> @options is {:a => {:a => {}, :b => {}, :c => {}}}

populate :a => [:a, :b, "c"]
=> @options is {:a => [:a, :b, "c"]}

populate :a => [:one], :b => [:two, :three => "four"]
=> @options is {:a => :one, :b => {:two => {}, :three => "four"}}

populate :a => [:one], :b => [:two => {:four => :five}, :three => "four"]
=> @options is {:a => :one,
                :b => {
                   :two => {
                      :four => :five
                      }
                   },
                   :three => "four"
                }
               }

如果需要更改 populate 的签名以适应某种递归版本，这是可以接受的。理论上可能发生的嵌套数量没有限制。

关于我如何实现这一目标有什么想法吗？

Answer 1

所以这里有一些有效的简单代码。

def to_value args
  ret = {}
  # make sure we were given an array
  raise unless args.class == Array
  args.each do |arg|
    case arg
    when Symbol
      ret[arg] = {} 
    when Hash
      arg.each do |k,v|
        # make sure that all the hash keys are symbols
        raise unless k.class == Symbol
        ret[k] = to_value v 
      end           
    else    
      # make sure all the array elements are symbols or symbol-keyed hashes
      raise         
    end     
  end
  ret
rescue
  args
end
def populate *args
  @options ||= {}
  value = to_value(args)
  if value.class == Hash
    @options.merge! value
  end
end

它确实偏离了您的测试用例：

• 测试用例 populate :a, :b => "apples", :c 是一个 ruby​​ 语法错误。 Ruby 将假定方法的final 参数是一个散列（当未给出大括号时），但不是非最终参数，正如您在此处所假设的那样。给定的代码是语法错误（无论 populate 的定义如何），因为它假定 :c 是哈希键，并且在查找 < 时找到行尾code>:c 的值。 填充：a，{：b => "apples"}, :c 按预期
• 测试用例 populate :a =>; [:一], :b => [：二，：三=> "four"] 返回 {:a=>{:one=>{}}、:b=>{:two=>{}、: Three=>"four" }}。这与测试用例 populate :a => 一致。 [:b]。

Answer 2

Ruby 不是 Perl，=> 只能在真正的哈希定义中工作或作为方法调用中的最终参数。大多数你想要的东西都会导致语法错误。

您确定仅限于 Ruby 语法支持的情况的 populate 值得吗？