按键排序散列，在Ruby中返回散列

这是排序哈希并返回哈希对象（而不是数组）的最佳方法吗

---

注意：Ruby>=1.9.2有一个保留顺序的散列：插入的顺序键将是它们的枚举顺序。以下内容适用于旧版本或向后兼容的代码

没有排序哈希的概念。所以不，你做的不对

如果要对其进行排序以便显示，请返回字符串：

"{" + h.sort.map{|k,v| "#{k.inspect}=>#{v.inspect}"}.join(", ") + "}"

或者，如果您希望钥匙按顺序排列：

h.keys.sort

h.sort.map do |key,value|
  # keys will arrive in order to this block, with their associated value.
end

或者，如果要按顺序访问元素：

h.keys.sort

h.sort.map do |key,value|
  # keys will arrive in order to this block, with their associated value.
end

---

但总的来说，谈论排序散列毫无意义。从中可以看出，“按键或值遍历哈希的顺序可能是任意的，并且通常不按插入顺序。”因此，在散列中按特定顺序插入键是没有帮助的。

如果您不想使用ruby 1.9.2或使用自己的解决方案，这是另一种选择。

我喜欢前面文章中的解决方案

我制作了一个迷你类，称之为

类字母哈希

。它还有一个名为

ap

的方法，它接受一个参数

Hash

，作为输入：

ap变量

。类似于pp（

pp变量

）

但它会（尝试）按字母顺序（其键）打印。不知道如果其他人想使用它，它可以作为gem提供，您可以这样安装：

gem install alphastical_hash

对我来说，这很简单。如果其他人需要更多功能，让我们 我知道，我会把它列入宝石

---

编辑：这要归功于谁给了我这个主意。：）

您在OP中给了自己最好的答案：

Hash[h.sort]

如果您渴望更多的可能性，这里是对原始Hash的适当修改，以使其排序：

h.keys.sort.each { |k| h[k] = h.delete k }

不，不是（Ruby 1.9.x）

---

对于大散列，差异将增加到10倍甚至更多

我一直使用

排序依据

。您需要将

#sort by

输出与

Hash[]

包装在一起，使其输出一个散列，否则它将输出一个数组数组。或者，要实现这一点，您可以对元组数组运行

#to_h

方法，将它们转换为

k=>v

结构（哈希）

@ordered = {}
@unordered.keys.sort.each do |key|
  @ordered[key] = @unordered[key]
end

---

Ruby 2.1中的“.”

中有一个类似的问题，很简单：

h.sort.to_h

我也遇到了同样的问题（我必须按设备名称对设备进行分类），我这样解决：

<% @equipments.sort.each do |name, quantity| %>
...
<% end %>

...

@设备是一个散列，我建立在我的模型上，并返回到我的控制器上。如果调用.sort，它将根据哈希的键值对哈希进行排序

按键对哈希进行排序，返回Ruby中的哈希

使用解构和散列排序

哈希#使用默认行为进行排序

h = { "b" => 2, "c" => 1, "a" => 3  }
h.sort         # e.g. ["a", 20] <=> ["b", 30]
hash.sort.to_h #=> { "a" => 3, "b" => 2, "c" => 1 }

注意：>Ruby 2.1

[["key", "value"]].to_h #=> {"key"=>"value"}

---

---

这是正确的。我建议使用RBtree gem在ruby中获得有序集功能。将保留1.9.2哈希插入顺序。请参阅“开始1.9.2哈希插入顺序将被保留”。这很好。这是我的第一条评论（感觉很有趣）：例如，对于1.9.2以上的Ruby版本，依赖哈希顺序会悄无声息地、不可预测地中断。这个答案是如何得到大约20+1的，而没有回答OP问题的两个部分中的任何一个？“1）这（操作示例）是排序散列的最佳方法吗，2）并返回散列对象”？我不羡慕+1:）就在阅读完答案后，我还剩下原来的问题。另外，如果问题的关键是没有排序的散列，那么请查看注释以便选择此问题的答案，我不确定排序散列有多大好处，除非您使用

每个

或

每个\u对

对其进行迭代。即使这样，我可能仍然会抓取这些键，对它们进行排序，然后迭代它们，根据需要抓取值。这确保了代码在较旧的ruby上正确运行，在ruby 1.9中也有意义。我有一个按日期分组的约会集合（作为键），来自db，我通过ruby手动排序。例如{“2012-09-22”：[…]，“2012-09-30”：[…]，“2012-10-12”：[…]）是的，我发现您的哈希[h.sort]过程比排序键更有效，然后通过排序键再次访问哈希。“会有用的。你已经花了几年时间考虑你的解决方案，你准备好接受答案了吗？；-）如果ruby没有Hash#sort_byuse

sort_by

之类的方法，那么在Hash上将返回一个数组。您需要再次将其映射为散列

Hash[hsh.sort_by{k，v{v}]

yes，枚举器类将哈希解释为数组I thinkRight，排序基于值：

hsh.sort_by（&:last）。to_h=>10，“a=>1000，“c=>200000}

，注意只有Ruby 2.1.0支持调用

to_h

，注释中有输入错误，请更正：

sort_by{k}.to|h）

出于好奇，它的运行速度比Ruby 1.9.3中的“键排序”稍快。@zachaysan但它确实有效：

h.sort{a，z | az}.to|h

（测试2.1.10，2.3.3）@whitehat101你是对的。我有一个bug（

a

是一个数组，而不仅仅是键）。我已经删除了我的评论。为了防止其他人正在寻找对哈希数组进行排序的方法，这将起到作用（其中h是数组）：

h.map（&:sort）.map（&:to_h）

。我不会使用此解决方案，因为它不是最快的。对于小散列，它是可以的，但是对于几千个键，它比

h.keys.sort.map{k |[k，h[k]]}.to_h

慢10倍。不确定C级别的差异在哪里，但在基准测试中非常清楚。即使是

sort\u by（&:first）

也要快得多。@KaplanIlya可能区别在于排序键和排序整个散列。尽管如此，我还是更喜欢简单和简洁，我会选择这个解决方案，而不是更复杂的解决方案，除非散列足够大，因为它是一个明显的区别。如果是这样的话，排序一个散列可能不是最好的架构决策：）链接被断开了我修复了指向谷歌的链接，以防有什么问题

hash.sort_by { |k, v| k }.to_h

h = { "b" => 2, "c" => 1, "a" => 3  }
h.sort         # e.g. ["a", 20] <=> ["b", 30]
hash.sort.to_h #=> { "a" => 3, "b" => 2, "c" => 1 }

array = [["key", "value"]] 
hash  = Hash[array]
hash #=> {"key"=>"value"}

[["key", "value"]].to_h #=> {"key"=>"value"}