Rails 有条件地按自定义顺序循环哈希

Question

我正在研究ROR Web应用程序。

我必须根据哈希的值按自定义顺序循环一系列哈希。

在此示例中，“待处理”状态需要首先出现在列表中。

是否可以自定义每个循环中数组的顺序？

<% example_statuses = [{ :status => "Active", :job_count => 0 }, { :status => "Pending", :job_count => 1 }, { :status => "Complete", :job_count => 3 }] %>
<% example_statuses.each do |es| %>
  <h3><%= es[:status] %></h3>
<% end %>

更新： 我有一个简单的工作示例，其中涉及删除和准备待处理的状态放回阵列中。但是，有没有一种方法可以创建自定义订单，而不是一个人手动替换值？

<% example_statuses = [{ :status => "Active", :job_count => 0 }, { :status => "Pending", :job_count => 1 }, { :status => "Complete", :job_count => 3 }] %>
<%= pending = example_statuses.find { |x| x[:status] == "Pending"} %>
<% example_statuses.delete(pending) %>
<% example_statuses.prepend(pending) %>
<% example_statuses.each do |es| %>
  <h3><%= es[:status] %></h3>
<% end %>

Answer 1

这里有两个重要的概念：

1. 使用数组＃索引在数组中找到一个元素。
2. “太空船运算符” ＆lt; =＆gt;，这是array＃sort工作的方式。您可以调查在您的情况下

在您的情况下解决方案是：

example_statuses = [{ :status => "Active", :job_count => 0 }, { :status => "Pending", :job_count => 1 }, { :status => "Complete", :job_count => 3 }]

order = ["Pending", "Active", "Complete"]

sorted_array = example_statuses.sort do |a,b|
  order.index(a[:status]) <=> order.index(b[:status])
end
# => [{:status=>"Pending", :job_count=>1}, {:status=>"Active", :job_count=>0}, {:status=>"Complete", :job_count=>3}]

Answer 2

您可以尝试使用像这样的单行 example_statuses.sort_by{|x| x[:状态] == '待处理' ? '' : x[:状态] }

Answer 3

据我了解，给您一个数组order，可以重新排序以相等

example_statuses.map { |h| h[:status] }
  #=> ["Active", "Pending", "Complete"]

，并且您希望对example_statuses进行排序以产生数组排序

sorted.map { |h| h[:status] } == order
  #=> true

您不需要实际对example_statues进行排序，它具有O（n*log（n））的计算复杂性，其中n等于example_statuses中的元素数。

相反，执行以下内容，其具有接近O（n）的计算复杂性。假设

order = ["Pending", "Active", "Complete"]

案例1：g [：status]！= h [：状态]对于所有不同元素的对example_statuses

在这种情况下，计算

example_statuses.each_with_object({}) { |g,h| h[g[:status]] = g }
                .values_at(*order)
  #=> [{:status=>"Pending", :job_count=>1},
  #    {:status=>"Active", :job_count=>0},
  #    {:status=>"Complete", :job_count=>3}]

hash＃values_at 被认为是以下内容。

example_statuses.each_with_object({}) { |g,h| h[g[:status]] = g }
  #=> {"Active"=>{:status=>"Active", :job_count=>0},
  #    "Pending"=>{:status=>"Pending", :job_count=>1},
  #    "Complete"=>{:status=>"Complete", :job_count=>3}}

---

我早些时候声称计算复杂性是“几乎” O（n）。构建哈希example_statuess.each_with_object（{}）{| g，h | h [g [：status]] = g}是o（n），但每个元素的密钥查找或order> order仅是“几乎” o（ 1）。是恒定的时间，复杂性将为o（n）。

案例2：g [：状态] == H [：状态]至少一对不同的元素g和h example_statuses

当然可能不允许使用这种情况，但该问题尚未清楚。

假设顺序与以前一样，但是example_statuses如下。

example_statuses = [
  { :status => "Active", :job_count => 0 },
  { :status => "Pending", :job_count => 1},
  { :status => "Complete", :job_count => 3 },
  { :status => "Active", :job_count => 7 }
]

请注意，example_statuses [0] [：状态]和example_statuses [3] [：status]均等“ active” 。

我们只需要对情况1计算（不影响计算复杂性）进行稍作修改。

example_statuses.each_with_object(Hash.new { |h,k| h[k] = [] }) do |g,h| 
  h[g[:status]] << g
end.values_at(*order).flatten
  #=> [{:status=>"Pending", :job_count=>1},
  #    {:status=>"Active", :job_count=>0},
  #    {:status=>"Active", :job_count=>7},
  #    {:status=>"Complete", :job_count=>3}]

values_at的接收器被认为等于以下内容。

{"Active"=>[{:status=>"Active", :job_count=>0},
            {:status=>"Active", :job_count=>7}],
 "Pending"=>[{:status=>"Pending", :job_count=>1}],
 "Complete"=>[{:status=>"Complete", :job_count=>3}]}

请参阅 hash :: new 的形式那需要一个障碍，没有参数。当h没有键[g [：status]这导致h [g [：status]]分配给空的在执行g [：status]＆lt;＆lt;执行之前的数组； G。