在 Ruby 中循环主集、处理每个子集的最简洁方法

Question

这是一种常见的情况，我对解决方案一直不太满意。您有一组数据，在本例中假设数据库中的行按类别排序。

您想要构建一个包含每个类别的子集的缓冲区，并对每个类别的更改进行一些处理，然后清除缓冲区。假设 process() 包含在一堆您不想重复的复杂逻辑中

有人有更好的设置吗？

# category, city
data = [
          [10, 'citya'],
          [10, 'cityb'],
          [11, 'citya'],
          [11, 'cityb'],
          [11, 'citya'],
          [12, 'cityb'],
          [12, 'cityg']
       ]

# do some heavy lifting in here
def process(buf) p buf; end

cur_cat = nil
cur_cat_buf = []
data.each do |r|
  if r[0] != cur_cat
    cur_cat = r[0]
    process(cur_cat_buf) #<-- assume this is conditional, complex
    cur_cat_buf.clear
  end
  cur_cat_buf << r[1]
end
process(cur_cat_buf) #<-- assume the conditional is duplicated...ack.

这是另一种技术，而且非常糟糕。乱七八糟，糟透了！总是向前看，检查它是否为零或不同等等...呃...

cur_cat = data[0][0] if data.length > 0
cur_cat_buf = []
data.each_with_index do |r, i|
  cur_cat_buf << r[1]

  # look ahead
  if data[i+1] == nil or data[i+1][0] != cur_cat
    cur_cat = data[i+1][0] if data[i+1] != nil
    process(cur_cat_buf)
    cur_cat_buf.clear
  end
end

这是另一种选择。当然比上一张好。

cur_cat = nil
cur_cat_buf = []
for i in 0..(data.length)
  if (r = data[i]) == nil or r[0] != cur_cat
    process(cur_cat_buf)
    break unless r

    cur_cat_buf.clear
    cur_cat = r[0]
  end

  cur_cat_buf << r[1]
end

我想要一个干净、优雅的解决方案。一定有更好的办法！

Answer 1

data.group_by(&:first).each_value {|buffer| process(buffer.map &:last) }

Answer 2

data.group_by(&:first).each_value do |pairs| 
  process(pairs.map(&:last)) 
end

或者等效的，但稍微更详细，但更明确：

data.group_by { |category_id, city| category_id }.each_value do |pairs| 
  process(pairs.map { |category_id, cities| cities }) 
end