根据散列中键的值对散列数组进行排序？

Question

我正在尝试与 Vagrant 合作，在启动 Docker 容器时执行一些自动化操作。 Vagrantfiles 本质上是 Ruby，因此我应该能够应用 Ruby 逻辑来帮助解决这个问题。

我正在阅读一个 conf.d 目录，该目录中充满了包含配置数据的 YAML 文件，然后将配置项的哈希值推送到一个数组中。完成后，我将使用 .each 遍历数组，并根据散列中某些键的值将配置应用于数组中的每个条目。这些键之一是“链接”。链接的值将与另一个键“名称”的值相关。

我基本上需要确保link => 'name' 的哈希值在name => 'value' 的哈希值之前的数组中。

输入和预期输出示例：

输入

containers = [{"name"=>"foo", "ports"=>["80:80", "443:443"], "links"=>["bar", "baz"]}, {"name"=>"bar", "ports"=>["8888:8888"]}, {"name"=>"baz","ports"=>"80:80"}]

预期输出

containers = [{"name"=>"bar", "ports"=>["8888:8888"]}, {"name"=>"baz", "ports"=>"80:80"}, {"name"=>"foo", "ports"=>["80:80", "443:443"], "links"=>["bar", "baz"]}]

最终结果是，任何带有“链接”的条目都会出现在数组中哈希的名称键与之匹配的条目之后。 （基本上是基于链接键的依赖排序。）

请注意，链接的容器可能会链接到另一个链接的容器。

这让我有点困惑，因为我知道我需要做什么，但缺乏真正弄清楚“如何做”的技术能力。 :)

提前感谢您的帮助。

Answer 1

这应该适合你：

def order_containers(containers)
  unordered = containers.dup
  ordered = []
  names_from_ordered = {}
  name_is_ordered = names_from_ordered.method(:[])
  until unordered.empty?
    container = unordered.find do |c|
      c.fetch('links', []).all? &name_is_ordered
    end
    raise 'container ordering impossible' if !container
    ordered << container
    unordered.delete(container)
    names_from_ordered[container.fetch('name')] = true
  end
  ordered
end

containers = [
  { 'name'=>'foo', 'links'=>['bar'] },
  { 'name'=>'a', 'links'=>['goo'] },
  { 'name'=>'bar' },
  { 'name'=>'goo', 'links'=>['foo'] },
]

containers = order_containers(containers)

require 'pp'
pp containers
# => [{"name"=>"bar"},
#     {"name"=>"foo", "links"=>["bar"]},
#     {"name"=>"goo", "links"=>["foo"]},
#     {"name"=>"a", "links"=>["goo"]}]

基本思想是我们使用一个循环，循环的每一次迭代都会从输入列表中找到一个适合添加到输出列表的容器。如果容器所依赖的所有容器都已添加到输出列表中，则该容器适合添加到输出列表中。然后将容器从输入列表中删除并添加到输出列表中。

这个循环可以通过两种主要方式终止：

1. 当输入列表为空时，表示成功，或者
2. 当我们找不到可以启动的容器时，这将是循环依赖导致的错误。

Answer 2

在我看来，最简单的事情是这样的：

linkless_configs = []
linked_configs = []
if config_hash.has_key?("links")
  linked_configs.push(config_hash)
else
  linkless_configs.push(config_hash)
end

然后您可以迭代 linkless_configs + linked_configs 并保证每个链接的配置都在相应的无链接配置之后。

或者，如果你必须排序，你可以

containers.sort_by { |config| config.has_key?("links") ? 1 : 0 }

Answer 3

[编辑： @DavidGrayson 指出我的回答存在缺陷。我会看看我是否能找到解决办法，但如果我不能，我担心可能是这种情况，我会删除答案。 [编辑#2：哦，天哪！在我最初的编辑之后，有人赞成我的回答。我不确定我现在可以删除它，但说实话，我已经决定不这样做，主要是因为我的解释对任何针对 OP 问题的建议解决方案都有影响。在余额中有 10 分的情况下，将其保留现在更加引人注目。 2#tidE]

我相信我理解这个问题。 sort 需要一个全序，这是一个偏序，其中每对元素都有a <= b 或a <= b。 ref 后者没问题，但偏序要求是。偏序必须满足以下公理：

• 自反性 (x ≤ x)，
• 反对称（如果x ≤ y 和y ≤ x 然后x = y）和
• 传递性（如果x ≤ y 和y ≤ z，那么x ≤ z）。

我的排序只满足反身公理。大卫给出了反例：

containers = [h0, h1, h2]

在哪里

h0 = {'name'=>'foo', 'links'=>['bar']},
h1 = {'name'=>'a'},
h2 = {'name'=>'bar'},

containers.sort
  #=> [{"name"=>"foo", "links"=>["bar"]},
  #    {"name"=>"a"}, {"name"=>"bar"}]

我的方法Hash#<=>建立：

h0 = h1
h0 > h2
h1 = h2

如果sort 找到h0 = h1 = h2，它将通过传递性得出h0 = h2（而不检查h0 <=> h2），这可能会导致错误的结果。

David 还指出 o.follows?(self) 应该引发异常，因为我已将其定义为 private。由于我还没有遇到异常，所以我断定该语句没有被执行，但我没有追查其原因，但这是一个小问题（尽管无疑是一个有用的线索）。

感谢大卫发现问题。当然，不正确的答案需要公开，但我觉得我也学到了一些有用的东西。

潮]

如果我正确理解了问题，并且数据提供了有效的排序，我认为您可以按以下方式进行。

class Hash
  def <=>(o)
    case
    when   follows?(o)    then  1
    when o.follows?(self) then -1
    else                        0
    end
  end

  private

  def follows?(o)
    key?("links") && self["links"].include?(o["name"])
  end
end

containers = [{"name"=>"foo", "ports"=>["80:80", "443:443"],
               "links"=>["bar", "baz"]},
              {"name"=>"bar", "ports"=>["8888:8888"]},
              {"name"=>"baz","ports"=>"80:80"}]

containers.sort
  #=> [{"name"=>"baz", "ports"=>"80:80"},
  #    {"name"=>"bar", "ports"=>["8888:8888"]},
  #    {"name"=>"foo", "ports"=>["80:80", "443:443"],
  #     "links"=>["bar", "baz"]}] 

附录

尽管我假设数据提供了有效的排序，但@Ajedi32 询问当存在循环引用时会发生什么。让我们找出答案：

containers = [{"name"=>"foo", "links"=>["bar"]},
              {"name"=>"bar", "links"=>["baz"]},
              {"name"=>"baz", "links"=>["foo"]}]
containers.sort
  #=> [{ "name"=>"baz", "links"=>["foo"] },
  #    { "name"=>"bar", "links"=>["baz"] },
  #    { "name"=>"foo", "links"=>["bar"] }]

containers = [{"name"=>"foo", "links"=>["bar"]},
              {"name"=>"bar", "links"=>["foo"]}]
containers.sort
  #=> [{ "name"=>"bar", "links"=>["foo"] },
  #    { "name"=>"foo", "links"=>["bar"] }]

这表明，如果不确定没有循环引用，则应在排序前检查。