Ruby 如果值为don'；不存在

我需要使用排序键将散列a的值合并到out

a={“X”=>{12=>1，11=>4}，“Y”=>{11=>5}，“Z”=>{12=>5}
out=[
{“X”：[4，1]}，
{“Y”：[5,0]}，
{“Z”：[0,5]}，
]

我会这样做：

a = {"X"=>{12=>1, 11=>4}, "Y"=>{11=>5}, "Z"=>{12=>5}}

sorted_keys = a.values.flat_map(&:keys).uniq.sort
#=> [11, 12]
a.map { |k, v| { k => v.values_at(*sorted_keys).map(&:to_i) } }
#=> [ { "X" => [4, 1] }, { "Y" => [5, 0] }, { "Z" => [0, 5] }]

---

我会这样做：

a = {"X"=>{12=>1, 11=>4}, "Y"=>{11=>5}, "Z"=>{12=>5}}

sorted_keys = a.values.flat_map(&:keys).uniq.sort
#=> [11, 12]
a.map { |k, v| { k => v.values_at(*sorted_keys).map(&:to_i) } }
#=> [ { "X" => [4, 1] }, { "Y" => [5, 0] }, { "Z" => [0, 5] }]

代码

def modify_values(g)
  sorted_keys = g.reduce([]) {|arr,(_,v)| arr | v.keys}.sort
  g.each_with_object({}) {|(k,v),h| h[k] = Hash.new(0).merge(v).values_at(*sorted_keys)}
end

g = {"X"=>{12=>1, 11=>4}, "Y"=>{11=>5}, "Z"=>{12=>5}}
modify_values(g)
  #=> {"X"=>[4, 1], "Y"=>[5, 0], "Z"=>[0, 5]}

示例

def modify_values(g)
  sorted_keys = g.reduce([]) {|arr,(_,v)| arr | v.keys}.sort
  g.each_with_object({}) {|(k,v),h| h[k] = Hash.new(0).merge(v).values_at(*sorted_keys)}
end

g = {"X"=>{12=>1, 11=>4}, "Y"=>{11=>5}, "Z"=>{12=>5}}
modify_values(g)
  #=> {"X"=>[4, 1], "Y"=>[5, 0], "Z"=>[0, 5]}

解释

步骤如下（对于示例中的哈希

a

）。首先从

g

的值中获取一个唯一键数组（请参见和），然后对该数组进行排序

b = a.reduce([]) {|arr,(_,v)| arr | v.keys}
  #=> [12, 11] 
sorted_keys = b.sort
  #=> [11, 12]

a

的第一个键值对连同一个空散列一起被传递到

每个带有\u对象的\u块。块变量使用并行赋值计算：

然后执行块计算。首先创建一个默认值为
0
的空哈希：

f = Hash.new(0)
  #=> {}

然后将散列
v
合并到
f
中。结果是哈希值与
v
的键值对相同，但默认值为
0
。默认值的意义在于，如果
f
没有键
k
，
f[k]
返回默认值。看

然后提取与排序的\u键对应的值：

 h[k] = g.values_at(*sorted_keys)
   #=> {12=>1, 11=>4}.values_at(11, 12) 
   #=> [4, 1]

当
a
的下一个键值对被传递到块时，计算如下

(k,v),h = [["Y", {11=>5}], {"X"=>[4, 1]}] # Note `h` has been updated 
k #=> "Y" 
v #=> {11=>5} 
h #=> {"X"=>[4, 1]}
f = Hash.new(0)
  #=> {} 
g = f.merge(v)
  #=> {11=>5} 
h[k] = g.values_at(*sorted_keys)
  #=> {11=>5}.values_at(11, 12) 
  #=> [5, 0] (Note h[12] equals h's default value)

现在呢

h #=> {"X"=>[4, 1], "Y"=>[5, 0]} 

a的第三个键值对的计算类似。
code

def modify_values(g)
  sorted_keys = g.reduce([]) {|arr,(_,v)| arr | v.keys}.sort
  g.each_with_object({}) {|(k,v),h| h[k] = Hash.new(0).merge(v).values_at(*sorted_keys)}
end

g = {"X"=>{12=>1, 11=>4}, "Y"=>{11=>5}, "Z"=>{12=>5}}
modify_values(g)
  #=> {"X"=>[4, 1], "Y"=>[5, 0], "Z"=>[0, 5]}

示例

def modify_values(g)
  sorted_keys = g.reduce([]) {|arr,(_,v)| arr | v.keys}.sort
  g.each_with_object({}) {|(k,v),h| h[k] = Hash.new(0).merge(v).values_at(*sorted_keys)}
end

g = {"X"=>{12=>1, 11=>4}, "Y"=>{11=>5}, "Z"=>{12=>5}}
modify_values(g)
  #=> {"X"=>[4, 1], "Y"=>[5, 0], "Z"=>[0, 5]}

解释

步骤如下（对于示例中的哈希
a
）。首先从
g
的值中获取一个唯一键数组（请参见和），然后对该数组进行排序

b = a.reduce([]) {|arr,(_,v)| arr | v.keys}
  #=> [12, 11] 
sorted_keys = b.sort
  #=> [11, 12]

a
的第一个键值对连同一个空散列一起被传递到
每个带有\u对象的\u块。块变量使用并行赋值计算：

然后执行块计算。首先创建一个默认值为
0
的空哈希：

f = Hash.new(0)
  #=> {}

然后将散列
v
合并到
f
中。结果是哈希值与
v
的键值对相同，但默认值为
0
。默认值的意义在于，如果
f
没有键
k
，
f[k]
返回默认值。看

然后提取与排序的\u键对应的值：

 h[k] = g.values_at(*sorted_keys)
   #=> {12=>1, 11=>4}.values_at(11, 12) 
   #=> [4, 1]

当
a
的下一个键值对被传递到块时，计算如下

(k,v),h = [["Y", {11=>5}], {"X"=>[4, 1]}] # Note `h` has been updated 
k #=> "Y" 
v #=> {11=>5} 
h #=> {"X"=>[4, 1]}
f = Hash.new(0)
  #=> {} 
g = f.merge(v)
  #=> {11=>5} 
h[k] = g.values_at(*sorted_keys)
  #=> {11=>5}.values_at(11, 12) 
  #=> [5, 0] (Note h[12] equals h's default value)

现在呢

h #=> {"X"=>[4, 1], "Y"=>[5, 0]} 

a
的第三个键值对的计算类似。
您的键值是否总是
11
和
12
？否。。它可以不同，但结构是相同的：“NAME”=>“num_key”=>num_valy为什么在输出中Y和Z都是零？为什么它们位于不同的位置？我需要它来表示图表数据。我需要一个包含合并值的散列。因此，我想对“X”、“Y”、“Z”的键进行排序，然后在合并时，如果内部散列没有ex.11的值，那么我需要放入0。您的键总是
11
和
12
？否。。它可以不同，但结构是相同的：“NAME”=>“num_key”=>num_valy为什么在输出中Y和Z都是零？为什么它们位于不同的位置？我需要它来表示图表数据。我需要一个包含合并值的散列。所以我想对“X”、“Y”、“Z”的键进行排序，然后在合并时，如果内部散列没有ex11的值，那么我需要将0放入。