Question

我是红宝石的新手，我的哈希数据如下。

person = {
  "PoolName.11.22.33":"pool_a",
  "PoolMemberName.11.22.33.11":"member_pool_a1",
  "PoolMemberScore.11.22.33.11":0,
  "PoolName.11.22.44":"pool_b",
  "PoolMemberName.11.22.44.11":"member_pool_b1",
  "PoolMemberName.11.22.44.12":"member_pool_b2",
  "PoolMemberScore.11.22.44.11":2,
  "PoolMemberScore.11.22.44.12":3,
  "PoolName.11.22.55":"pool_c",
  "PoolMemberName.11.22.55.11":"member_pool_c1",
  "PolMemberName.11.22.55.12":"member_pool_c2",
  "PoolMemberName.11.22.55.13":"member_pool_c3",
  "PoolMemberScore.11.22.55.11":11,
  "PoolMemberScore.11.22.55.12":22,
  "PoolMemberScore.11.22.55.13":33
}

我能否获得如下所示的结果：

"pool_a.member_pool_a1" : 0,
"pool_b.member_pool_b1" : 2,
"pool_b.member_pool_b2" : 3,
"pool_c.member_pool_c1" : 11,
"pool_c.member_pool_c2" : 22,
"pool_c.member_pool_c3" : 33

Answer 1

person.
  slice_before { |_,v| v.is_a?(String) &&
    v.match?(/\Apool_\p{Lower}{,2}\z/) }.
  each_with_object({}) do |((_, pool), *rest),h|
    pool_str = pool + ".member_pool_"
    rest.group_by { |k,_| k[/(?:\.\d+)+\z/] }.
         each do |_,((_,s),(_,n))|
           (s,n = n,s) if n.is_a?(String)
           h[(pool_str + s[/[^_]+\z/]).to_sym] = n
         end  
  end
  #=> {:"pool_a.member_pool_a1"=>0,
  #    :"pool_b.member_pool_b1"=>2,
  #    :"pool_b.member_pool_b2"=>3,
  #    :"pool_c.member_pool_c1"=>11,
  #    :"pool_c.member_pool_c2"=>22,
  #    :"pool_c.member_pool_c3"=>33}

步骤如下¹。

c = person.slice_before { |_,v| v.is_a?(String) &&
      v.match?(/\Apool_\p{Lower}{,2}\z/) }
  #=> #<Enumerator: #<Enumerator::Generator:0x00005d500f652950>:each>

我们可以看到此枚举器将其转换为数组所生成的值。

c.to_a
  #=> [[[:"PoolName.11.22.33", "pool_a"],
  #     [:"PoolMemberName.11.22.33.11", "member_pool_a1"],
  #     [:"PoolMemberScore.11.22.33.11", 0]],
  #    [[:"PoolName.11.22.44", "pool_b"],
  #     [:"PoolMemberName.11.22.44.11", "member_pool_b1"], 
  #     [:"PoolMemberName.11.22.44.12", "member_pool_b2"],
  #     [:"PoolMemberScore.11.22.44.11", 2],
  #     [:"PoolMemberScore.11.22.44.12", 3]],
  #    [[:"PoolName.11.22.55", "pool_c"],
  #     [:"PoolMemberName.11.22.55.11", "member_pool_c1"],
  #     [:"PolMemberName.11.22.55.12", "member_pool_c2"],
  #     [:"PoolMemberName.11.22.55.13", "member_pool_c3"],
  #     [:"PoolMemberScore.11.22.55.11", 11],
  #     [:"PoolMemberScore.11.22.55.12", 22],
  #     [:"PoolMemberScore.11.22.55.13", 33]]]

如所见，c生成3个数组，三个池“ a”，“ b”和“ c”中的每个池一个。参见Enumerable#slice_before。继续

d = c.each_with_object({})
  #=> #<Enumerator: #<Enumerator:
  # #<Enumerator::Generator:0x00005d500f652950>:each>
  #   :each_with_object({})>

d可以被视为复合枚举器，尽管Ruby没有这种概念。参见Enumerable#each_with_object。生成第一个元素并将其传递给块，然后将块变量分配给该值。

((_, pool), *rest),h = d.next
  #=> [[[:"PoolName.11.22.33", "pool_a"],
  #     [:"PoolMemberName.11.22.33.11", "member_pool_a1"], 
  #     [:"PoolMemberScore.11.22.33.11", 0]], {}]

我们看到块变量现在具有以下值。

pool
  #=> "pool_a" 
rest
  #=> [[:"PoolMemberName.11.22.33.11", "member_pool_a1"],
  #    [:"PoolMemberScore.11.22.33.11", 0]]
h #=> {}

将数组分解成它们感兴趣的部分称为"array decomposition"（搜索“数组分解”）。也称为数组消除歧义。这是一种非常强大且有用的技术。请注意，_是有效的但有些特殊的局部变量。使用下划线（或以下划线开头的变量名称）的主要原因是告知读者该变量未在后续计算中使用。继续

pool_str = pool + ".member_pool_"
  #=> "pool_a.member_pool_" 
e = rest.group_by { |k,_| k[/(?:\.\d+)+\z/] }
  #=> {".11.22.33.11"=>[
  #     [:"PoolMemberName.11.22.33.11", "member_pool_a1"],
  #     [:"PoolMemberScore.11.22.33.11", 0]]}

请参见Enumerable#group_by。继续

g = e.each
  #=> #<Enumerator:
  #    {".11.22.33.11"=>[
  #      [:"PoolMemberName.11.22.33.11", "member_pool_a1"],
  #      [:"PoolMemberScore.11.22.33.11", 0]]}:each>

很多枚举符，是吗？再次，生成枚举数的第一个元素并将其传递给块，并为块变量分配值：

p,((q,s),(r,n)) = g.next
  #=> [".11.22.33.11",
  #   [[:"PoolMemberName.11.22.33.11", "member_pool_a1"],
  #    [:"PoolMemberScore.11.22.33.11", 0]]]
p #=> ".11.22.33.11"
q #=> :"PoolMemberName.11.22.33.11"
s #=> "member_pool_a1"
r #=> :"PoolMemberScore.11.22.33.11"
n #=> 0

p，q和r未在块计算中使用。因此，我对所有这三个变量都使用了_：

each do |_,((_,s),(_,n))| ...

此数组分解可能看起来极其复杂，但实际上并非如此。只需将上面一行中括号的位置与上面显示的g.next返回值中括号的位置进行比较即可。

现在执行块计算。我们无法确定g.next的两个元素的顺序正确（尽管它们在这里），因此如果需要，我们可以将它们反转。

(s,n = n,s) if n.is_a?(String)
  #=> nil 
s #=> "member_pool_a1" 
n #=> 0 

i = s[/[^_]+\z/]
  #=> "a1" 
j = pool_str + i
  #=> "pool_a.member_pool_a1" 
k = j.to_sym
  #=> :"pool_a.member_pool_a1" 
h[k] = n
  #=> 0 
h #=> {:"pool_a.member_pool_a1"=>0}

作为g.size #=> 1，我们以g结尾。因此，下一步就是生成d的下一个元素（池“ b”）：

((_, pool), *rest),h = d.next
  #=> [[[:"PoolName.11.22.44", "pool_b"],
  #     [:"PoolMemberName.11.22.44.11", "member_pool_b1"],
  #     [:"PoolMemberName.11.22.44.12", "member_pool_b2"],
  #     [:"PoolMemberScore.11.22.44.11", 2], 
  #     [:"PoolMemberScore.11.22.44.12", 3]],
  #    {:"pool_a.member_pool_a1"=>0}] 
pool
  #=> "pool_b"
rest
  #=> [[:"PoolMemberName.11.22.44.11", "member_pool_b1"],
  #    [:"PoolMemberName.11.22.44.12", "member_pool_b2"],
  #    [:"PoolMemberScore.11.22.44.11", 2],
  #    [:"PoolMemberScore.11.22.44.12", 3]]
h #=> {:"pool_a.member_pool_a1"=>0}

注意如何更新块变量h。其余计算类似。

^{1位经验丰富的红宝石：血腥细节警报！}

从动态键和值获取Ruby哈希（MIB SNMP）

1 个答案: