ruby-数组按子元素分组

我需要将这个YAML结构按数组元素分组

这是我的YAML结构的示例：

articles:
  - title: 'Title 1'
    url: 'https://example.com'
    data: July 21, 2017
    categories:
      - 'category 1'
      - 'category 2'
  - title: 'Title 2'
    url: 'https://example.com'
    data: July 23, 2017
    categories:
      - 'category 2'

我需要的结果是这样或类似的：

['category 1' => 
    [
        {title: 'Title 1', url: 'https://example.com', data: July 21, 2017, categories: ['category 1', 'category 2']}
    ], 
    'category 2' => [
        {title: 'Title 1', url: 'https://example.com', data: July 21, 2017, categories: ['category 1', 'category 2']},
        {title: 'Title 2', url: 'https://example.com', data: July 23, 2017, categories: ['category 2']}
    ]
]

你能帮我吗？先谢谢你

更新：

我试过这个：

articles.group_by(&:categories).map{|v, a| [v, a] }

但关键不是单个类别，而是类别元素。我想我需要一个更大的循环，但经过一些试验，我还没有得到结果

很抱歉，我是ruby的新手

更新2: 错误的结果是：

[
  [
    [
      "category 1",
      "category 2"
    ],
    [
      {
        "title": "Title 1",
        "url": "https://example.com",
        "data": "July 21, 2017",
        "categories": [
          "category 1",
          "category 2"
        ]
      }
    ]
  ],
  [
    [
      "category 2"
    ],
    [
      {
        "title": "Title 2",
        "url": "https://example.com",
        "data": "July 23, 2017",
        "categories": [
          "category 2"
        ]
      }
    ]
  ]
]

---

你需要一个小组吗？为什么不是一个简单的嵌套循环

result = {}
articels.each do |article|
  article.categories.each do |cat|
    result[cat] ||= []
    result[cat] << article
  end
end

result={}
每件物品|
第条.类别.每个do |类别|
结果[cat]| |=[]
结果[cat]您需要一个分组人吗？为什么不是一个简单的嵌套循环

result = {}
articels.each do |article|
  article.categories.each do |cat|
    result[cat] ||= []
    result[cat] << article
  end
end

result={}
每件物品|
第条.类别.每个do |类别|
结果[cat]| |=[]
结果[cat]看来，在这种情况下，普通的老式优质减速器更适合您的需要：

articles.each_with_object({}) do |article, acc|
  acc.merge! article.categories.map { |c| [c, article] }.to_h
end

甚至：

articles.map do |article|
  article.categories.map { |c| [c, article] }.to_h
end.reduce(&:merge)

在这种情况下，普通的老式优质减速器似乎更适合您的需要：

articles.each_with_object({}) do |article, acc|
  acc.merge! article.categories.map { |c| [c, article] }.to_h
end

甚至：

articles.map do |article|
  article.categories.map { |c| [c, article] }.to_h
end.reduce(&:merge)

你被困在哪里？我已经更新了我的问题。谢谢，所需的输出是否正确？类别2是否应该是类别1的子元素？“但键不是单一类别”–请显示（错误）结果好吗？顺便说一句，您的预期结果似乎是散列，但表示为数组文字，即您使用的是
[key=>value]
而不是
{key=>value}
。请解决这个问题以避免混淆。你被困在哪里？我已经更新了我的问题。谢谢，所需的输出是否正确？类别2是否应该是类别1的子元素？“但键不是单一类别”–请显示（错误）结果好吗？顺便说一句，您的预期结果似乎是散列，但表示为数组文字，即您使用的是
[key=>value]
而不是
{key=>value}
。请修复此问题以避免混淆。您正在滥用带有初始局部变量的
每个
。请改用
每个带有对象的\u
。@mudasobwa没错，这更像是一句话，他应该能够用简单的方法解决这个问题。这不是展示最佳方式的想法。无论如何，您的解决方案非常好，总是乐于阅读类似的内容；-）您正在使用初始局部变量滥用每个
。请改用
每个带有对象的\u
。@mudasobwa没错，这更像是一句话，他应该能够用简单的方法解决这个问题。这不是展示最佳方式的想法。无论如何，您的解决方案非常好，总是乐于阅读类似的内容；-）