解决这个 ruby​​ 迭代器棘手问题的干净解决方案吗？

Question

k = [1,2,3,4,5]
for n in k
  puts n
  if n == 2
    k.delete(n)
  end
end
puts k.join(",")

# Result:
# 1
# 2
# 4
# 5
# [1,3,4,5]

# Desired:
# 1
# 2
# 3
# 4
# 5
# [1,3,4,5]

同样的效果也发生在另一个数组迭代器 k.each: 上，

k = [1,2,3,4,5]
k.each do |n|
  puts n
  if n == 2
    k.delete(n)
  end
end
puts k.join(",")

具有相同的输出。

发生这种情况的原因非常清楚......Ruby 实际上并没有迭代存储在数组中的对象，而是将其变成一个漂亮的数组索引迭代器，从索引 0 开始，每次增加索引直到结束。但是当您删除一个项目时，它仍然会增加索引，因此它不会对同一个索引进行两次评估，而这正是我想要的。

这可能不是正在发生的事情，但这是我能想到的最好的情况。

有没有一种干净的方法来做到这一点？是否已经有一个内置迭代器可以做到这一点？或者我是否必须将其弄脏并执行数组索引迭代器，并且在删除项目时不增加？ （或迭代数组的克隆，然后从原始数组中删除）

---

澄清

我不想简单地从数组中删除项目；我想从数组中删除项目。抱歉，如果说清楚的话。我想做的是迭代每个元素，并“处理”它；此过程有时可能会删除它。更准确地说：

class Living_Thing

  def initialize tracker,id
    @tracker = tracker
    @id = id

    @tracker << self
  end

  def process
    do_stuff
    puts @id
    if @id == 2
      die
    end
  end

  def die
    do_stuff_to_die
    @tracker.delete(self)
  end

  def inspect
    @id
  end
end

tracking_array = Array.new()

foo = Living_Thing.new(tracking_array,1)
bar = Living_Thing.new(tracking_array,2)
rab = Living_Thing.new(tracking_array,3)
oof = Living_Thing.new(tracking_array,4)

puts tracking_array.join(",")              # => [1, 2, 3, 4]

for n in tracking_array
  n.process
end

# result: only foo, bar, and oof are processed

理想情况下，我希望处理 track_array 中的所有项目。

当Living_Thing从tracking_array中删除时，必须调用Living_Thing#die； do_stuff_to_die 清理必须清理的东西。

Answer 1

在大多数语言中，在迭代集合时改变集合是错误的。在大多数语言中，解决方案是创建一个副本并对其进行变异，或者构建一个索引列表，并在完成迭代后对这些索引执行操作，但 Ruby 的迭代器为您提供的功能远不止这些。有几个解决方案是显而易见的。最惯用的IMO：

puts k
puts k.reject {|n| n == 2}.join(',')

更直接地从您的示例翻译：（

k.delete_if do |n|
  puts n
  n == 2
end
puts k.join(',')

delete_if基本上是reject的破坏性版本，它返回块未返回true的对象的数组为了。）

Answer 2

这可能更适合处理（参考更新的澄清）

k = [1,2,3,4,5] 
k.dup.each do |n| 
  puts n 
  if n == 2
    k.delete(n) 
  end 
end 
puts k.join(",")

它回避了您所遇到的问题（关于通过对象的迭代与通过索引的迭代）

Answer 3

好吧，假设您想从数组中消除所有 2：

arr = [1,2,3,4,5]
arr.delete(2)
puts arr.join(", ")
# => "1, 3, 4, 5"
arr = [1,2,3,2,4,2,5,2]
arr.delete(2)
puts arr.join(", ")
# => "1, 3, 4, 5"

但我怀疑您想迭代，所以我会：

arr = [1,2,3,4,5]
arr.each {|x| a[a.index(x)] = nil if x == 2}.compact!

也许这太脏了？对 nil 的赋值使迭代器计数保持正确，并且 compact! 会在事后清除 nils。 Course map 使其变得更短并且更清晰：

arr.map {|x| x if x != 2}.compact!