如何在散列中交换键和值

当然有了! 在 Ruby 里做事情总是有捷径的！

这很简单，只要使用 Hash#invert:

{a: :one, b: :two, c: :three}.invert
=> {:one=>:a, :two=>:b, :three=>:c}

就是这样！

Ruby 为 Hash 提供了一个 helper 方法，可以将 Hash 视为反向的(实质上，通过值访问键) :

{a: 1, b: 2, c: 3}.key(1)
=> :a

如果你想保持反向散列，那么 散列 # 反转应该可以在大多数情况下工作:

{a: 1, b: 2, c: 3}.invert
=> {1=>:a, 2=>:b, 3=>:c}

但是..。

如果有重复的值，invert将丢弃除了最后出现的值之外的所有值(因为在迭代期间它将不断替换该键的新值)。同样，key只返回第一个匹配项:

{a: 1, b: 2, c: 2}.key(2)
=> :b


{a: 1, b: 2, c: 2}.invert
=> {1=>:a, 2=>:c}

因此，如果值是唯一的，则可以使用 Hash#invert。如果没有，那么您可以将所有值保存为一个数组，如下所示:

class Hash
# like invert but not lossy
# {"one"=>1,"two"=>2, "1"=>1, "2"=>2}.inverse => {1=>["one", "1"], 2=>["two", "2"]}
def safe_invert
each_with_object({}) do |(key,value),out|
out[value] ||= []
out[value] << key
end
end
end

注意: 这段带有测试的代码现在是 在 GitHub 上。

或者:

class Hash
def safe_invert
self.each_with_object({}){|(k,v),o|(o[v]||=[])<<k}
end
end

# this doesn't looks quite as elegant as the other solutions here,
# but if you call inverse twice, it will preserve the elements of the original hash


# true inversion of Ruby Hash / preserves all elements in original hash
# e.g. hash.inverse.inverse ~ h


class Hash


def inverse
i = Hash.new
self.each_pair{ |k,v|
if (v.class == Array)
v.each{ |x|
i[x] = i.has_key?(x) ? [k,i[x]].flatten : k
}
else
i[v] = i.has_key?(v) ? [k,i[v]].flatten : k
end
}
return i
end


end

Hash#inverse为您提供:

 h = {a: 1, b: 2, c: 2}
h.inverse
=> {1=>:a, 2=>[:c, :b]}
h.inverse.inverse
=> {:a=>1, :c=>2, :b=>2}  # order might not be preserved
h.inverse.inverse == h
=> true                   # true-ish because order might change

而内置的 invert方法只是被打破了:

 h.invert
=> {1=>:a, 2=>:c}    # FAIL
h.invert.invert == h
=> false             # FAIL

使用数组

input = {:key1=>"value1", :key2=>"value2", :key3=>"value3", :key4=>"value4", :key5=>"value5"}
output = Hash[input.to_a.map{|m| m.reverse}]

使用 Hash

input = {:key1=>"value1", :key2=>"value2", :key3=>"value3", :key4=>"value4", :key5=>"value5"}
output = input.invert

files = {
'Input.txt' => 'Randy',
'Code.py' => 'Stan',
'Output.txt' => 'Randy'
}


h = Hash.new{|h,k| h[k] = []} # Create hash that defaults unknown keys to empty an empty list
files.map {|k,v| h[v]<< k} #append each key to the list at a known value
puts h

这也将处理重复的值。

如果您有一个散列，其中键是唯一的，您可以使用 散列 # 反转:

> {a: 1, b: 2, c: 3}.invert
=> {1=>:a, 2=>:b, 3=>:c}

但是，如果你有非唯一的密钥，那么这种方法就不起作用了，因为只有最后一个密钥才会被保留:

> {a: 1, b: 2, c: 3, d: 3, e: 2, f: 1}.invert
=> {1=>:f, 2=>:e, 3=>:d}

如果您有一个具有非唯一键的 hash，您可以这样做:

> hash={a: 1, b: 2, c: 3, d: 3, e: 2, f: 1}
> hash.each_with_object(Hash.new { |h,k| h[k]=[] }) {|(k,v), h|
h[v] << k
}
=> {1=>[:a, :f], 2=>[:b, :e], 3=>[:c, :d]}

如果散列的值已经是数组，则可以执行以下操作:

> hash={ "A" => [14, 15, 16], "B" => [17, 15], "C" => [35, 15] }
> hash.each_with_object(Hash.new { |h,k| h[k]=[] }) {|(k,v), h|
v.map {|t| h[t] << k}
}
=> {14=>["A"], 15=>["A", "B", "C"], 16=>["A"], 17=>["B"], 35=>["C"]}