Ruby 使哈希键与哈希常量的顺序匹配_Ruby_Sorting_Hash

Ruby 使哈希键与哈希常量的顺序匹配

ruby sorting hash

Ruby 使哈希键与哈希常量的顺序匹配,ruby,sorting,hash,Ruby,Sorting,Hash,我有许多散列，它们包含相同的键，但彼此之间的顺序都不一致。我需要对每一个进行重新排序，使其符合正确的顺序： correct_order = { :cat => "cat", :dog => "dog", :bear => "bear", :zebra => "zebra", :monkey => "monkey" } hash1 = { :bear => "bear", :cat => "cat" } hash2 = {

我有许多散列，它们包含相同的键，但彼此之间的顺序都不一致。我需要对每一个进行重新排序，使其符合正确的顺序：

correct_order = {
  :cat => "cat",
  :dog => "dog",
  :bear => "bear",
  :zebra => "zebra",
  :monkey => "monkey"
}

hash1 = {
  :bear => "bear",
  :cat => "cat"
}

hash2 = {
  :cat => "cat",
  :monkey => "monkey",
  :zebra => "zebra",
  :bear => "bear"
}

hash3 = {
  :dog => "dog",
  :monkey => "monkey",
  :cat => "cat"
}

如何比较hash1、hash2和hash3的键顺序，使每个键匹配其在正确的散列顺序中的位置？hash2将变成：

hash2 {
  :cat => "cat",
  :bear => "bear",
  :zebra => "zebra",
  :monkey => "monkey"
}

注意，每个新的散列不一定都有所有的键。每个散列将具有不同的大小和顺序

谢谢

您不能对哈希进行“排序”

说明：哈希按插入相应键的顺序枚举其值

因此，您必须创建一个新的哈希。例如：

def sort_hash(ordered_keys, hash_to_sort)
  new_hash= {}
  ordered_keys.each do |key|
    new_hash[key]= hash_to_sort[key] if hash_to_sort.has_key?(key)
  end
  new_hash
end

correct_order = {
  :cat => "cat",
  :dog => "dog",
  :bear => "bear",
  :zebra => "zebra",
  :monkey => "monkey"
}

hash2 = {
  :cat => "cat",
  :monkey => "monkey",
  :zebra => "zebra",
  :bear => "bear"
}
puts sort_hash(correct_order.keys, hash2)

请注意，该函数返回一个新的哈希值。哈希2未被修改。

您不能对哈希进行“排序”

说明：哈希按插入相应键的顺序枚举其值

因此，您必须创建一个新的哈希。例如：

def sort_hash(ordered_keys, hash_to_sort)
  new_hash= {}
  ordered_keys.each do |key|
    new_hash[key]= hash_to_sort[key] if hash_to_sort.has_key?(key)
  end
  new_hash
end

correct_order = {
  :cat => "cat",
  :dog => "dog",
  :bear => "bear",
  :zebra => "zebra",
  :monkey => "monkey"
}

hash2 = {
  :cat => "cat",
  :monkey => "monkey",
  :zebra => "zebra",
  :bear => "bear"
}
puts sort_hash(correct_order.keys, hash2)

请注意，该函数返回一个新的哈希值。哈希2未被修改。

您不能对哈希进行“排序”

说明：哈希按插入相应键的顺序枚举其值

因此，您必须创建一个新的哈希。例如：

def sort_hash(ordered_keys, hash_to_sort)
  new_hash= {}
  ordered_keys.each do |key|
    new_hash[key]= hash_to_sort[key] if hash_to_sort.has_key?(key)
  end
  new_hash
end

correct_order = {
  :cat => "cat",
  :dog => "dog",
  :bear => "bear",
  :zebra => "zebra",
  :monkey => "monkey"
}

hash2 = {
  :cat => "cat",
  :monkey => "monkey",
  :zebra => "zebra",
  :bear => "bear"
}
puts sort_hash(correct_order.keys, hash2)

请注意，该函数返回一个新的哈希值。哈希2未被修改。

您不能对哈希进行“排序”

说明：哈希按插入相应键的顺序枚举其值

因此，您必须创建一个新的哈希。例如：

def sort_hash(ordered_keys, hash_to_sort)
  new_hash= {}
  ordered_keys.each do |key|
    new_hash[key]= hash_to_sort[key] if hash_to_sort.has_key?(key)
  end
  new_hash
end

correct_order = {
  :cat => "cat",
  :dog => "dog",
  :bear => "bear",
  :zebra => "zebra",
  :monkey => "monkey"
}

hash2 = {
  :cat => "cat",
  :monkey => "monkey",
  :zebra => "zebra",
  :bear => "bear"
}
puts sort_hash(correct_order.keys, hash2)

请注意，该函数返回一个新的哈希值。hash2没有被修改。

关于hash元素的顺序，需要说些什么，但我会在向您展示如何做您想做的事情之后解决这个问题。这假设您使用的是Ruby 1.9+，其中保留了键插入的顺序

代码

def reorder(hash, order)
  keys = order & hash.keys
  Hash[keys.zip(hash.values_at(*keys))]
end

示例

order = correct_order.keys
  #=> [:cat, :dog, :bear, :zebra, :monkey]

reorder(hash1, order)
  #=> {:cat=>"cat", :bear=>"bear"}
reorder(hash2, order)
  #=> {:cat=>"cat", :bear=>"bear", :zebra=>"zebra", :monkey=>"monkey"}
reorder(hash3, order)
  #=> {:cat=>"cat", :dog=>"dog", :monkey=>"monkey"}

解释

让我们看看代码是如何处理hash1的：

hash = hash1
  #=> {:bear=>"bear", :cat=>"cat"}
order 
  #=> [:cat, :dog, :bear, :zebra, :monkey]
keys = order & hash.keys
  #=> [:cat, :dog, :bear, :zebra, :monkey] & [:bear, :cat]
  #=> [:cat, :bear] 
arr = keys.zip(hash.values_at(*keys))
  #=> keys.zip({:bear=>"bear", :cat=>"cat"}.values_at(*[:cat, :bear]))
  #=> keys.zip({:bear=>"bear", :cat=>"cat"}.values_at(:cat, :bear))
  #=> keys.zip(["cat", "bear"])
  #=> [[:cat, "cat"], [:bear, "bear"]]
Hash[arr]
  #=> {:cat=>"cat", :bear=>"bear"}

在Ruby 1.9+中，您可以将最后一步写成：

arr.to_h

请注意，该方法保留第一个数组的顺序

散列顺序

在Ruby1.9之前，您不能依赖于散列中键值对（我们只说键）的顺序。这在1.9中发生了变化。现在您可以确信，当您枚举散列的键时，枚举的顺序将遵循键添加到散列的顺序。要注意的是，这种变化并没有被所有的红宝石学家所接受。如果二十年来你一直认为散列是无序的集合，那么这是一个很大的变化。就我个人而言，我喜欢这一变化，并发现了它的良好用途。

关于散列元素的顺序，需要说些什么，但我会在向您展示如何做您想做的事情之后解决这个问题。这假设您使用的是Ruby 1.9+，其中保留了键插入的顺序

代码

def reorder(hash, order)
  keys = order & hash.keys
  Hash[keys.zip(hash.values_at(*keys))]
end

示例

order = correct_order.keys
  #=> [:cat, :dog, :bear, :zebra, :monkey]

reorder(hash1, order)
  #=> {:cat=>"cat", :bear=>"bear"}
reorder(hash2, order)
  #=> {:cat=>"cat", :bear=>"bear", :zebra=>"zebra", :monkey=>"monkey"}
reorder(hash3, order)
  #=> {:cat=>"cat", :dog=>"dog", :monkey=>"monkey"}

解释

让我们看看代码是如何处理hash1的：

hash = hash1
  #=> {:bear=>"bear", :cat=>"cat"}
order 
  #=> [:cat, :dog, :bear, :zebra, :monkey]
keys = order & hash.keys
  #=> [:cat, :dog, :bear, :zebra, :monkey] & [:bear, :cat]
  #=> [:cat, :bear] 
arr = keys.zip(hash.values_at(*keys))
  #=> keys.zip({:bear=>"bear", :cat=>"cat"}.values_at(*[:cat, :bear]))
  #=> keys.zip({:bear=>"bear", :cat=>"cat"}.values_at(:cat, :bear))
  #=> keys.zip(["cat", "bear"])
  #=> [[:cat, "cat"], [:bear, "bear"]]
Hash[arr]
  #=> {:cat=>"cat", :bear=>"bear"}

在Ruby 1.9+中，您可以将最后一步写成：

arr.to_h

请注意，该方法保留第一个数组的顺序

散列顺序

关于散列元素的顺序，需要说些什么，但我会在向您展示如何做您想做的事情之后解决这个问题。这假设您使用的是Ruby 1.9+，其中保留了键插入的顺序

代码

def reorder(hash, order)
  keys = order & hash.keys
  Hash[keys.zip(hash.values_at(*keys))]
end

示例

order = correct_order.keys
  #=> [:cat, :dog, :bear, :zebra, :monkey]

reorder(hash1, order)
  #=> {:cat=>"cat", :bear=>"bear"}
reorder(hash2, order)
  #=> {:cat=>"cat", :bear=>"bear", :zebra=>"zebra", :monkey=>"monkey"}
reorder(hash3, order)
  #=> {:cat=>"cat", :dog=>"dog", :monkey=>"monkey"}

解释

让我们看看代码是如何处理hash1的：

hash = hash1
  #=> {:bear=>"bear", :cat=>"cat"}
order 
  #=> [:cat, :dog, :bear, :zebra, :monkey]
keys = order & hash.keys
  #=> [:cat, :dog, :bear, :zebra, :monkey] & [:bear, :cat]
  #=> [:cat, :bear] 
arr = keys.zip(hash.values_at(*keys))
  #=> keys.zip({:bear=>"bear", :cat=>"cat"}.values_at(*[:cat, :bear]))
  #=> keys.zip({:bear=>"bear", :cat=>"cat"}.values_at(:cat, :bear))
  #=> keys.zip(["cat", "bear"])
  #=> [[:cat, "cat"], [:bear, "bear"]]
Hash[arr]
  #=> {:cat=>"cat", :bear=>"bear"}

在Ruby 1.9+中，您可以将最后一步写成：

arr.to_h

请注意，该方法保留第一个数组的顺序

散列顺序

关于散列元素的顺序，需要说些什么，但我会在向您展示如何做您想做的事情之后解决这个问题。这假设您使用的是Ruby 1.9+，其中保留了键插入的顺序

代码

def reorder(hash, order)
  keys = order & hash.keys
  Hash[keys.zip(hash.values_at(*keys))]
end

示例

order = correct_order.keys
  #=> [:cat, :dog, :bear, :zebra, :monkey]

reorder(hash1, order)
  #=> {:cat=>"cat", :bear=>"bear"}
reorder(hash2, order)
  #=> {:cat=>"cat", :bear=>"bear", :zebra=>"zebra", :monkey=>"monkey"}
reorder(hash3, order)
  #=> {:cat=>"cat", :dog=>"dog", :monkey=>"monkey"}

解释

让我们看看代码是如何处理hash1的：

hash = hash1
  #=> {:bear=>"bear", :cat=>"cat"}
order 
  #=> [:cat, :dog, :bear, :zebra, :monkey]
keys = order & hash.keys
  #=> [:cat, :dog, :bear, :zebra, :monkey] & [:bear, :cat]
  #=> [:cat, :bear] 
arr = keys.zip(hash.values_at(*keys))
  #=> keys.zip({:bear=>"bear", :cat=>"cat"}.values_at(*[:cat, :bear]))
  #=> keys.zip({:bear=>"bear", :cat=>"cat"}.values_at(:cat, :bear))
  #=> keys.zip(["cat", "bear"])
  #=> [[:cat, "cat"], [:bear, "bear"]]
Hash[arr]
  #=> {:cat=>"cat", :bear=>"bear"}

在Ruby 1.9+中，您可以将最后一步写成：

arr.to_h

请注意，该方法保留第一个数组的顺序

散列顺序