0

所以，我很清楚在迭代块中删除项目的危险（这是反向循环），我知道 Matz 提到了一些关于迭代中的突变导致稳定性问题，但我似乎无法弄清楚这一点.

这个例子有点复杂，我不确定即使解决它也会完全复制这个例子，但我必须尝试。

arr1 = [1, 2, 3, 4, 5]
arr2 = [3, 4, 5]
puts arr1.inspect
puts arr2.inspect
arr2.each do |i|
  arr1.reverse.each_with_index do |j, index|
    if i == j
      arr1.delete_at(index)
    end
  end
end
puts arr1.inspect
puts arr2.inspect

输出：

[1, 2, 3, 4, 5]
[3, 4, 5]
[4, 5]
[3, 4, 5]

什么时候应该：

[1, 2, 3, 4, 5]
[3, 4, 5]
[1, 2]
[3, 4, 5]

将 delete_at(index) 更改为 delete(j) 可以解决此问题，但当数组是对象时不起作用。我还将对象复制到临时数组以使事情变得更加复杂。

在我的现实生活场景中，我有两个数组，其中填充了不同类型的 Model 对象，但共享一个公共属性（可能在这里使用连接，但我试图避免使用特殊的连接表）。我想要的是删除array1 中所有在array2 中具有共同属性的对象。我尝试了许多不同的方法，但没有解决方案……太多了，无法放在这里。

@arr1 = []
original_arr1 = Model1.where(...)
original_arr1.each { |original| @arr1 << original.dup }
@arr2 = Model2.where(...)
@arr2.each do |object1|
  @arr1.reverse.each_with_index do |object2, index|
    if object1.color == object2.color
      @arr1.delete_at(version_index)
    end
  end
end

如果没有上面的额外复制，模型关联将保留，我最终会从表中删除记录，这不应该发生。这只是一个临时清单。这似乎是一个愚蠢的问题，我花了太多时间在它上面。

4

3 回答 3

1

您正在使用反向索引进行删除，但从原始数组中删除。

要获得“真实”索引，而不是从数组末尾开始计数，您需要将其翻转：

arr1.delete_at(-index - 1)

...但您几乎肯定应该使用reject!ordelete_if代替：

require "set"

unwanted_colors = @arr2.map(&:color).to_set
@arr1.reject! { |el| unwanted_colors.include?(el.color) }
于 2018-08-19T09:37:41.930 回答
1

您的问题有多种解决方案，@matthewds answer显示了一个干净的示例。但是，以下两种解决方案也可以解决您的问题。

首先我想让你知道你可以减少前几行代码：

@arr1 = []
original_arr1 = Model1.where(...)
original_arr1.each { |original| @arr1 << original.dup }
# to
@arr1 = Model1.where(...).map(&:dup)
# but since you're not saving the Model1.where(...) result in a variable
# (enabling one to use them later), there is not need to dup at all
@arr1 = Model1.where(...)

问题

你得到的实际结果是正确的。原因如下：

a1 = [1, 2]
a2 = [2]

a2.each { |n2| a1.reverse.each_with_index { |n1, i| a1.delete_at(i) if n2 == n1 }  }

# a1 = [1, 2]
# a2 = [2]
# iterate over a2
# n2 = 2
# create an new array with the reversed elements of a1
# ra1 = a1.reverse (eq [2, 1] and a1 is still [1, 2])
# iterate over ra1 with index
# n1 = 2, i = 0
# does n2 (2) equals n1 (2)? yes
# delete in a1 ([1, 2]) at the index i (0)
# resulting in a1 = [2]
# next iteration ra1
# n1 = 1, i = 1
# does n2 (2) equals n1 (1)? no
# ra1 iteration finishes
# a2 iteration finishes
# resulting in a1 = [2]

#1 保持你当前的代码结构

如果您想要针对当前代码结构的最简单的解决方案，只需删除#reverse调用就足够了。似乎无论如何都不需要反转数组，因为您不保存结果或在#each_with_index代码块中使用。

#2 只获取你需要的记录

第二个解决方案解决了数据库查询级别的问题。如果您不希望记录Model1的颜色与当前集合中的颜色相同，则不要从数据库中获取它们。

@arr2 = Model2.where(...)
@arr1 = Model1.where(...).where.not(color: @arr2.pluck(:color))

如果颜色不是属性，而是关联实例，请:color_id改用。

注意：您可以使用.select(:color)代替.pluck(:color). 使用select方法会产生一个子查询，但是因为您可能要使用@arr2记录，所以无论如何都需要完整加载。从中提取值@arr2并将它们提供为纯色而不是子查询可以为数据库节省一些工作。如果您不打算@arr2进一步使用，我会使用select变体。

于 2018-08-19T10:47:57.800 回答
0

我没有用复杂的数据结构测试它，但也许这可能是另一种方式。

a = [1, 2, 3, 4, 5]
b = [3, 4, 5]

p a+b-(a&b)
p a&b

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

这也适用于：

a = [3, 4, 5]
b = [1, 2, 3, 4, 5]
于 2018-08-19T11:15:29.670 回答