在Ruby中用值交换散列键并将键转换为符号？

这是输入哈希：

p Score.periods #{"q1"=>0, "q2"=>1, "q3"=>2, "q4"=>3, "h1"=>4, "h2"=>5}

这是我的当前代码，用于在将键转换为符号时，将键与值交换：

periods = Score.periods.inject({}) do |hsh,(k,v)|
  hsh[v] = k.to_sym
  hsh
end

结果如下：

p periods #{0=>:q1, 1=>:q2, 2=>:q3, 3=>:q4, 4=>:h1, 5=>:h2}

看起来我的代码很笨重，我在这里做的事情不需要4行代码。有没有更干净的方法来写这篇文章？

您可以这样做：

Hash[periods.values.zip(periods.keys.map(&:to_sym))]

periods.values.zip(periods.keys.map(&:to_sym)).to_h

或者，如果您正在使用可用于阵列的Ruby版本，则可以执行以下操作：

Hash[periods.values.zip(periods.keys.map(&:to_sym))]

periods.values.zip(periods.keys.map(&:to_sym)).to_h

上面的两个示例所做的是生成原始散列的键和值的数组。请注意，散列的字符串键通过传递到_sym映射为Proc映射到符号：

然后，它将它们压缩成一个[value，key]对数组，其中每个对应的值元素都与其对应的key in key匹配：

然后可以使用hash[array]或array将该数组转换回散列。要执行此操作，请执行以下操作：

Hash[periods.values.zip(periods.keys.map(&:to_sym))]

periods.values.zip(periods.keys.map(&:to_sym)).to_h

或者，如果您正在使用可用于阵列的Ruby版本，则可以执行以下操作：

Hash[periods.values.zip(periods.keys.map(&:to_sym))]

periods.values.zip(periods.keys.map(&:to_sym)).to_h

上面的两个示例所做的是生成原始散列的键和值的数组。请注意，散列的字符串键通过传递到_sym映射为Proc映射到符号：

然后，它将它们压缩成一个[value，key]对数组，其中每个对应的值元素都与其对应的key in key匹配：

然后可以使用hash[array]或array.toh将该数组转换回哈希

为了Ruby新手的利益，步骤如下

enum = h.each_with_object({})
  #=> #<Enumerator: {0=>"q1", 1=>"q2", 2=>"q3", 3=>"q4",
  #                  4=>"h1", 5=>"h2"}:each_with_object({})>

继续

enum.each { |(k,v),g| g[v] = k.to_sym  }
  #=> {0=>:q1, 1=>:q2, 2=>:q3, 3=>:q4, 4=>:h1, 5=>:h2}

在最后一步中，将enum生成的第一个元素传递给块，并分配三个块变量。考虑传递给块的枚举的第一个元素和三个块变量的相关值计算。我必须首先执行enum.rewind来重新初始化enum，因为上面的每一步都将枚举数带到了末尾。看

看。因此，区块计算是可行的

g[v] = k.to_sym
  #=> :q1

因此,

g #=> {0=>:q1}

enum的下一个元素被传递到块，并执行类似的计算

(k, v), g = enum.next
  #=> [["q2", 1], {0=>:q1}] 
k #=> "q2" 
v #=> 1 
g #=> {0=>:q1} 
g[v] = k.to_sym
  #=> :q2 
g #=> {0=>:q1, 1=>:q2} 

其余的计算是类似的

为了Ruby新手的利益，步骤如下

enum = h.each_with_object({})
  #=> #<Enumerator: {0=>"q1", 1=>"q2", 2=>"q3", 3=>"q4",
  #                  4=>"h1", 5=>"h2"}:each_with_object({})>

继续

enum.each { |(k,v),g| g[v] = k.to_sym  }
  #=> {0=>:q1, 1=>:q2, 2=>:q3, 3=>:q4, 4=>:h1, 5=>:h2}

在最后一步中，将enum生成的第一个元素传递给块，并分配三个块变量。考虑传递给块的枚举的第一个元素和三个块变量的相关值计算。我必须首先执行enum.rewind来重新初始化enum，因为上面的每一步都将枚举数带到了末尾。看

看。因此，区块计算是可行的

g[v] = k.to_sym
  #=> :q1

因此,

g #=> {0=>:q1}

enum的下一个元素被传递到块，并执行类似的计算

(k, v), g = enum.next
  #=> [["q2", 1], {0=>:q1}] 
k #=> "q2" 
v #=> 1 
g #=> {0=>:q1} 
g[v] = k.to_sym
  #=> :q2 
g #=> {0=>:q1, 1=>:q2} 

其余的计算方法类似。

最简单的方法是：

data = {"q1"=>0, "q2"=>1, "q3"=>2, "q4"=>3, "h1"=>4, "h2"=>5}

Hash[data.invert.collect { |k, v| [ k, v.to_sym ] }]

Hash[]方法将键/值对数组转换为实际的哈希。在这种情况下非常方便

如果您使用的是Ruby on Rails，这可能会更容易：

data.symbolize_keys.invert

最简单的方法是：

data = {"q1"=>0, "q2"=>1, "q3"=>2, "q4"=>3, "h1"=>4, "h2"=>5}

Hash[data.invert.collect { |k, v| [ k, v.to_sym ] }]

Hash[]方法将键/值对数组转换为实际的哈希。在这种情况下非常方便

如果您使用的是Ruby on Rails，这可能会更容易：

data.symbolize_keys.invert

---

美好的我在那里也有一个to|sym函数，所以我认为它必须是这个，Score.periods.values.zipScore.periods.keys.map{k|k.to|sym}.to_h@appleLover我把它做得比那个还要短，看看。@appleLover是RubyonRails的活动记录关系吗？如果是，在调用Score.periods两次时，请小心不要多次查询数据库。我不确定在你的情况下，它是否真的会被查询两次，只是一些你可能想再次检查你没有做的事情。很好。我在那里也有一个to|sym函数，所以我认为它必须是这个，Score.periods.values.zipScore.periods.keys.map{k|k.to|sym}.to_h@appleLover我把它做得比那个还要短，看看。@appleLover是RubyonRails的活动记录关系吗？如果是，在调用Score.periods两次时，请小心不要多次查询数据库。我不确定在你的情况下，它是否真的会被查询两次，只是一些你可能想再次检查你没有做的事情。重复的不是重复的，@Cupcake，一个近亲。这里的键是字符串，并被转换为符号值。@CarySwoveland这是一个很好的观点。不是dup的副本，@Cupcake，一个近亲。这里的键是字符串，并被转换为符号值。@CarySwoveland这是一个很好的观点。根据您的Ruby版本，您应该能够使用to_h而不是Hash[]，对吗？这是Ruby 2.1中添加的，所以是的，也有这个选项。您可以跳过反转：Hash[data.collect{k，v|[v，k.to_sym]]。我想我的评论也适用于我的答案。你应该能够使用to_h而不是Hash[]，这取决于你的Ruby版本，对吗？我相信这是Ruby 2.1中添加的，所以是的，有如下选项

---

嗯，你可以跳过反转：Hash[data.collect{k，v{k，k.to_sym]}。我想我的评论也适用于我的答案。