ruby - 如何在 ruby​​ 中进行递归

Question

我有一个哈希哈希显示为树，比如路由。下面，我添加了一个预期结果的示例以及我得到的结果。

示例哈希：

hash = {
          'movies' => {
            'action' => {
              '2007' => ['video1.avi', 'x.wmv'],
              '2008' => ['']
            },
            'comedy' => {
              '2007' => [],
              '2008' => ['y.avi']
            }
          },
          'audio' => {
            'rock' => {
              '2003' => [],
              '2004' => ['group', 'group1']
            }
          }
        }

我期待这个结果：

movies
movies\action
movies\action\2007
movies\action\2007\video1.avi
movies\action\2007\x.wmv
movies\action\2008
movies\comedy\2007
movies\comedy\2008
movies\comedy\2008\y.avi
audio
audio\rock\2003
audio\rock\2004
audio\rock\2004\group
audio\rock\2004\group1

这是我制作的一些代码：

def meth(key, val)
  val.each do |key1, val1|
    puts "#{key}/#{key1}"
    meth(key1, val1) if val1
  end
end

hash.each do |key, val|
  puts key
  meth(key,val)
end

它返回这个结果：

movies
movies/action
action/2007
2007/video1.avi
2007/x.wmv
action/2008
2008/
movies/comedy
comedy/2007
comedy/2008
2008/y.avi
audio
audio/rock
rock/2003
rock/2004
2004/group
2004/group1

任何人都可以解释如何做到这一点？

更新

感谢您的回答。在这种情况下，我想出了使用此代码。提示是设置key1为先前的结果。

def meth key, val
  val.each do |key1, val1|
    puts "#{key}/#{key1}"
    key1 = "#{key}/#{key1}"
    meth(key1, val1) if val1
  end
end

Answer 1

您可以将代码更改为：

def meth(key, val)
  val.each do |key1, val1|
    puts "#{key}/"
    if (val1 && val1.is_a?(Hash))
       meth(key1, val1)
    else
       puts "#{val1}"
    end
  end
end

您期望该方法根据调用位置的不同而有所不同，但事实并非如此。无论在哪里调用该方法（例如，如果它是由它自己调用的），该方法都会执行相同的操作。

递归是将一个问题分解为更小的子问题的行为。总会有至少两个。在您的情况下，两个子问题是 - 打印两个值 - 打印键并迭代哈希

至少有一个子问题需要结束递归，否则它将永远运行。在上述情况下，第一个子问题结束递归。

Answer 2

您必须以数组的形式跟踪路径：

def meth key, val
  val.each do |key1, val1|
    puts key.join("/")+"/"+key1
    meth(key + [key1], val1) if val1
  end
end

meth [], root_of_hash

Answer 3

当我有一个可以包含不同类型的类的嵌套结构时，我喜欢创建一个案例语句，以便轻松定义在不同场景中会发生什么。

def print_tree(input, path=[])
    case input
      when Hash then  input.flat_map{|x,y| print_tree(y, path+[x])}
      when Array then input.empty? ? [path] : input.map{|x| path+[x]}
    end
end
puts print_tree(my_hash).map{|z|z.join('/')}