这种类似哈希/树的结构叫什么？

Question

我想创建一个介于哈希和树之间的“Config”类。它只是用于存储可以有上下文的全局值。

我是这样使用它的：

Config.get("root.parent.child_b") #=> "value"

这个类可能看起来像这样：

class Construct

  def get(path)
    # split path by "."
    # search tree for nodes
  end

  def set(key, value)
    # split path by "."
    # create tree node if necessary
    # set tree value
  end

  def tree
    {
      :root => {
        :parent => {
          :child_a => "value",
          :child_b => "another value"
        },
        :another_parent => {
          :something => {
            :nesting => "goes on and on"
          }
        }
      }
    }
  end

end

这种东西有一个名字吗，介于 Hash 和 Tree 之间（不是计算机科学专业）？基本上是一个类似于树的哈希接口。

输出如下所示：

t = TreeHash.new
t.set("root.parent.child_a", "value")
t.set("root.parent.child_b", "another value")

所需的输出格式：

t.get("root.parent.child_a") #=> "value"
t.get("root") #=> {"parent" => {"child_a" => "value", "child_b" => "another value"}}

而不是此：

t.get("root") #=> nil

或此（您可以通过调用 {}.value 从中获取值）

t.get("root") #=> {"parent" => {"child_a" => {}, "child_b" => {}}}

Answer 1

您可以立即实现一个：

class TreeHash < Hash
  attr_accessor :value

  def initialize
    block = Proc.new {|h,k| h[k] = TreeHash.new(&block)}
    super &block
  end

  def get(path)
    find_node(path).value
  end

  def set(path, value)
    find_node(path).value = value
  end

private

  def find_node(path)
    path.split('.').inject(self){|h,k| h[k]}
  end
end

您可以通过将不需要的 Hash 方法设置为私有方法来改进实现，但它已经按照您想要的方式工作了。数据以 hash 形式存储，因此您可以轻松将其转换为 yaml。

---

EDIT:

为了满足进一步的期望（并且默认情况下正确转换to_yaml），您应该使用修改后的版本：

class TreeHash < Hash
  def initialize
    block = Proc.new {|h,k| h[k] = TreeHash.new(&block)}
    super &block
  end

  def get(path)
    path.split('.').inject(self){|h,k| h[k]}
  end

  def set(path, value)
    path = path.split('.')
    leaf = path.pop
    path.inject(self){|h,k| h[k]}[leaf] = value
  end
end

此版本是轻微的权衡，因为您无法在非叶节点中存储值。

Answer 2

我认为该结构的名称实际上是一个嵌套哈希，问题中的代码是对 javascript 字典的重新发明。由于 JS（或 Python 或...）中的字典可以嵌套，因此每个值都可以是另一个字典，它有自己的键/值对。在 javascript 中，这就是对象的全部。

最好的一点是能够使用 JSON 来整齐地定义它，并将其传递：

tree : {
  'root' : {
    'parent' : {
      'child_a' : "value",
      'child_b' : "another value"
    },
    'another_parent' : {
      'something' : {
        'nesting' : "goes on and on"
      }
    }
  }
};

在 JS 中，您可以执行 tree.root.parent.child_a 。

另一个问题的答案建议使用Hashie gem 将 JSON 对象转换为 Ruby 对象。

Answer 3

我认为这类似于 TreeMap 数据结构，类似于 此处。它执行相同的操作（键/值映射），但检索可能会有所不同，因为您使用节点本身作为键。从所描述的 TreeMap 检索是从实现中抽象出来的，因为当您传入一个键时，您不知道它在树中的确切位置。

希望这是有道理的！

Answer 4

呃...当然可以使用分层哈希表来完成，但是为什么需要分层结构呢？如果您只需要完全匹配的 get 和 put，为什么不能创建一个碰巧使用点分隔命名约定的哈希表呢？

这就是实现您所要求的功能所需的全部内容，而且显然非常简单......

Answer 5

为什么要使用类似哈希的接口？为什么不使用方法链来导航你的树呢？例如 config.root.parent.child_b 并使用实例方法，如果需要 method_missing() 来实现它们？