Hash自然遍历问题

h={
    1=>"a",
    21=>"b－1",
    22=>"b－2",
    23=>"b－3",
    3=>"c",
    4=>"d"
}

h.each do |k,v|
   puts k.to_s + "=>" + v
end

结果为：

22=>b－2
23=>b－3
1=>a
3=>c
4=>d
21=>b－1

我期望的结果应为:

1=>a
21=>b－1
22=>b－2
23=>b－3
3=>c
4=>d

一般的问题:Hash里每个元素是按照什么顺序建立的，那么就按照什么顺序遍历.ruby如何处理这个问题?

hash
这个词本身就包含了“无序”的意思

Hash，联想到其他语言的类似Hash之类的数据结构（比如java的HashTable,HashMap），都是无序的，应该是根据哈希码来查找的吧。

哈希表应该没有顺序

不知道ruby里有没有LinkedHashSet这样的东西、。

YAGNI

为什么？
ruby用什么来存储有顺序的hash？

You Aren't Gonna Need It

我问的就是why not，
看楼主的问题是他已经开始需要了。

自己实现一个也不是很难的事情吧，更简单地上rubyforge查找下就有了，比如这个项目http://rubyforge.org/frs/?group_id=728&release_id=2305

# A QueueHash is an ordered hash: Keys are ordered according to when they were 
# inserted.
#
# The RubyForge project page is at http://rubyforge.org/projects/queuehash .

require 'delegate'

class QueueHash < DelegateClass( Array )
	Version = '0.1.0'
	
	# Creates a QueueHash with all the elements in <tt>array</tt> as keys, and 
	# each value initially set to be the same as the corresponding key.
	def self.new_from_array(array)
		new( *( ( array.map { |elt| [ elt, elt ] } ).flatten ) )
	end

	# Takes an even number of arguments, and sets each odd-numbered argument to 
	# correspond to the argument immediately afterward. For example:
	#   queueHash = QueueHash.new (1, 2, 3, 4)
	#   queueHash[1] => 2
	#   queueHash[3] => 4
	def initialize(*values)
		@pairs = []
		0.step(values.size-1, 2) { |i| @pairs << [ values[i], values[i+1] ] }
		super( @pairs )
	end
	
	def ==( otherObj )
		if otherObj.class == QueueHash && otherObj.size == size
			( 0..size ).all? { |i|
				keys[i] == otherObj.keys[i] && values[i] == otherObj.values[i]
			}
		else
			false
		end
	end

	def [](key)
		( pair = @pairs.find { |pair| pair[0] == key } ) ? pair.last : nil
	end

	def []=(key, value); @pairs << [key, value]; end

	def each; @pairs.each { |pair| yield pair[0], pair[1] }; end

	def keys; @pairs.map { |pair| pair[0] }; end

	def values; @pairs.map { |pair| pair[1] }; end
end