为什么我的哈希中只有一个值被更改？

Question

我正在制作一个简单的 RPG 作为一个学习项目，但我遇到了角色创建者的一部分问题。

此代码应确定分配给player[:caste][:skill] 和player[:sub][:skill] 的技能字符串，然后将player[:skills] 中每个相应技能的值增加2。无论分配给player[:caste][:skill] 和@ 的字符串如何，此代码都应该有效987654325@，只要等于player[:skills].to_s。

目前，它仅将更改应用于player[:skills][:endurance]，而不是player[:skills][:athletics]。

player = {
  caste: {skill: "athletics"},
  sub: {skill: "endurance"},
  skills: {acrobatics: 0, athletics: 0, engineering: 0, endurance: 0, heal: 0, history: 0, influence: 0, insight: 0, magicka: 0, perception: 0, riding: 0, stealth: 0, streetwise: 0, thievery: 0},
}

player[:skills] = player[:skills].map do |skill, mod|
  [skill, (mod += 2 if skill.to_s == player[:caste][:skill])]
  [skill, (mod += 2 if skill.to_s == player[:sub][:skill])]
end.to_h

换句话说，我的代码返回以下player[:skills] 哈希：

skills: {acrobatics: 0, athletics: 0, engineering: 0, endurance: 2, heal: 0, history: 0, influence: 0, insight: 0, magicka: 0, perception: 0, riding: 0, stealth: 0, streetwise: 0, thievery: 0}

但我希望它返回：

skills: {acrobatics: 0, athletics: 2, engineering: 0, endurance: 2, heal: 0, history: 0, influence: 0, insight: 0, magicka: 0, perception: 0, riding: 0, stealth: 0, streetwise: 0, thievery: 0}

如果有更简单的方法，请告诉我。我还尝试了以下方法：

player[:skills] = player[:skills].map do |skill, mod|
  [skill, (mod += 2 if skill.to_s == (player[:caste][:skill] || player[:sub][:skill]))]
end.to_h

只影响player[:caste][:skill]中的技能。

Answer 1

当我运行你的代码时，我得到了这个结果。

{:acrobatics=>nil, :athletics=>nil, :engineering=>nil, :endurance=>2, :heal=>nil, :history=>nil, :influence=>nil, :insight=>nil, :magicka=>nil, :perception=>nil, :riding=>nil, :stealth=>nil, :streetwise=>nil, :thievery=>nil}

那是因为 map 返回最后执行的语句。此外，您实际上只在与子技能匹配时才为技能设置一个值，否则，它被设置为 nil。

因此，您的代码中发生的情况是，每次迭代都返回以下内容，这是传递给 map 的块中最后一条语句的结果。

[:acrobatics, nil]
[:athletics, nil]
[:engineering, nil]
[:endurance, 2]
[:heal, nil]
[:history, nil]
[:influence, nil]
[:insight, nil]
[:magicka, nil]
[:perception, nil]
[:riding, nil]
[:stealth, nil]
[:streetwise, nil]
[:thievery, nil]

最终结果是一个如下所示的数组。

[[:acrobatics, nil], [:athletics, nil], [:engineering, nil], [:endurance, 2], [:heal, nil], [:history, nil], [:influence, nil], [:insight, nil], [:magicka, nil], [:perception, nil], [:riding, nil], [:stealth, nil], [:streetwise, nil], [:thievery, nil]]

最终映射到一个新的哈希

{:acrobatics=>nil, :athletics=>nil, :engineering=>nil, :endurance=>2, :heal=>nil, :history=>nil, :influence=>nil, :insight=>nil, :magicka=>nil, :perception=>nil, :riding=>nil, :stealth=>nil, :streetwise=>nil, :thievery=>nil}

您得到所有​​这些 nil 的原因是因为在您的陈述中，如果 if 陈述不正确，则案例的结果是 nil。 例如：

[skill (mod += 2 if skill.to_s == player[:caste][:skill])]

如果 skill.to_s == player[:caste][:skill] 不正确，将返回 [the_skill, nil]

要查看发生了什么，请在 irb 中尝试此操作。

x = 0
=> 0
x += 1 if false
=> nil
x += 1 if true
=> 1 

你可以使用这样的东西来克服这个问题。

[skill, skill.to_s == player[:caste][:skill] ? mod + 2 : mod ]

或者使用上面的例子：

x = 0
=> 0
x =  false ? x + 1 : x 
=> 0
x =  true ? x + 1 : x
=> 1

您的代码的以下修改版本应该可以工作。

player[:skills] = player[:skills].map do |skill, mod|
  [skill, skill.to_s == player[:caste][:skill] || skill.to_s == player[:sub][:skill] ? mod + 2 : mod ]
end.to_h

但是，这里稍微有点冗长，但希望更容易遵循的方式来完成您想要做的事情，并允许在将来添加修改而不会让代码变得太混乱。

player = {
  caste: {skill: "athletics"},
  sub: {skill: "endurance"},
  skills: {acrobatics: 0, athletics: 0, engineering: 0, endurance: 0, heal: 0, history: 0, influence: 0, insight: 0, magicka: 0, perception: 0, riding: 0, stealth: 0, streetwise: 0, thievery: 0},
}

player_caste_skill = player[:caste][:skill]
player_sub_skill = player[:sub][:skill]
current_skills = player[:skills]
updated_skills = {}
current_skills.each_pair do |skill, prev_value| 
  new_value = prev_value 
  case skill.to_s
    when player_caste_skill, player_sub_skill
      new_value = prev_value + 2
    when "some_other_skill"  
      new_value = prev_value + 3
  end
  updated_skills[skill] = new_value
end
puts current_skills
puts updated_skills

Answer 2

我将默认值 (Hash#default) 设置为 player[:skill] 哈希，只是为了避免在缺少密钥的情况下出错（它添加了密钥！！），允许在不需要的情况下添加新密钥将每个技能初始化为 0。

player[:skills].default = 0

然后在一行中扫描您需要递增的键：

[:caste, :sub].each { |key| player.dig(key, :skill).to_sym.then { |skill| player[:skills][skill] += 2 } }

---

由于初始化，您的播放器也可以

player = {
  caste: {skill: "athletics"},
  sub: {skill: "endurance"},
  skills: {}
}

返回如下结果：

player #=> {:caste=>{:skill=>"athletics"}, :sub=>{:skill=>"endurance"}, :skills=>{:athletics=>2, :endurance=>2}}

地点：

player[:skills][:whatever] #=> 0

Answer 3

我会迭代定义的技能而不是技能值。

player.
  map { |_, h| h[:skill] }.
  compact.
  map(&:to_sym).
  each { |skill| player[:skills][skill] += 2 }

现在player 已相应更新，您可以通过检查player 和p player 或类似方法进行检查。

Answer 4

把代码改成这样：

player = {
 caste: {skill: "athletics"},
 sub: {skill: "endurance"},
 skills: {acrobatics: 0, athletics: 0, engineering: 0, endurance: 0, heal: 0, 
 history: 0, influence: 0, insight: 0, magicka: 0, perception: 0, riding: 0, 
 stealth: 0, streetwise: 0, thievery: 0},
}

player[:skills] = player[:skills].map do |skill, mod|
  [skill, (mod += 2 if [player[:caste][:skill], player[:sub][:skill]].include? 
  (skill.to_s))]
end.to_h

您的代码不起作用的原因是 map 返回最后一行作为当前迭代的结果，所以在athletics 的情况下，最后一行是

[skill, (mod += 2 if skill.to_s == player[:sub][:skill])]

将是 false，即 nil，这就是为什么只有 endurance 案例有效。

希望对你有帮助。