Arrays 嵌套块中数组和散列的奇怪行为

我在嵌套块中使用内部数组（或哈希）来保存数据：

p "#1 both inner_arr and outer_arr set empty outside of both loops"
outer_arr = []
inner_arr = []
i = 0
2.times{
  j = 0
  2.times{
    inner_arr[j] = j+100+i 
    j += 1
  }
  p inner_arr
  outer_arr[i] = inner_arr
  i += 1
  p outer_arr
}
p "======================================================"
p "#2 outer_arr set empty before both loops while inner_arr set empty inside of outer loop and outside of inner loop"
outer_arr_2 = []
i = 0
2.times{
  j = 0
  inner_arr_2 = []
  2.times{
    inner_arr_2 << j+100+i 
    j += 1
  }
  p inner_arr_2
  outer_arr_2[i] = inner_arr_2
  i += 1
  p outer_arr_2
}
p "======================================================"
p "#3 both outer and inner hash set empty outside of both loops"
outer_hash_3 = {}
inner_hash_3 = {}
i = 0
2.times{
  j = 0
  2.times{
    inner_hash_3 [j] = j+100+i 
    j += 1
  }
  p inner_hash_3
  outer_hash_3[i] = inner_hash_3
  i += 1
  p outer_hash_3
}
p "======================================================"
p "#4 outer_hash set empty before both loops while inner_hash set empty inside of outer loop and outside of inner loop"
outer_hash_4 = {}
i = 0
2.times{
  j = 0
  inner_hash_4 = {}
  2.times{
    inner_hash_4[j] = j+100+i 
    j += 1
  }
  p inner_hash_4
  outer_hash_4[i] = inner_hash_4
  i += 1
  p outer_hash_4
}

p“#1在两个循环外部，内部_arr和外部_arr都设置为空”
外部_arr=[]
内部_arr=[]
i=0
2.5倍{
j=0
2.5倍{
内螺纹[j]=j+100+i
j+=1
}
内弧
外部阵列[i]=内部阵列
i+=1
外耳道
}
p“=====================================================================================”
p“#2外部#arr在两个循环之前设置为空，而内部#arr在外部循环内部和内部循环外部设置为空”
外部阵列2=[]
i=0
2.5倍{
j=0
内部_arr_2=[]
2.5倍{
你在这里发现了一些东西，但我想你还没有完全理解它的影响

第二种形式是正确的方法，这是因为在第一种情况下，每次迭代都要循环使用相同的数组，每次插入数组时，都要反复插入相同的对象

这在这里得到了最好的证明：

a = [ 1 ]
b = [ a, a ]
# => [[1],[1]]

a << 2
# => [1,2]

b
# => [[1, 2], [1, 2]]

Ruby的可枚举库使这一切成为可能。试着将问题的解决方案想象为对数据的一系列转换。
这确实是太多的代码，我们无法通过。如果您不确定某个区域，请将其缩小，并声明“我希望会发生这种情况（有一些输出），但实际上发生了这种情况。”（有一些输出）“你的问题是什么？我的问题是我没有在外循环内部重置我的内部arr，它会返回到更新我先前保存在外部arr中的信息-这是一种奇怪的行为。如果执行p“#1两个内部arr和外部arr在两个循环外部都设置为空”外部arr=[]内部arr=[]I=0.2次{j=0 2.乘以{inner_arr[j]=j+100+i j+=1}p inner_arr outer_arr[i]=inner_arr i+=1 p outer_arr}它返回：[[101，102]，[101，102]]而不是[[100，101]，[101，102]]-预期的结果也许这些类型的问题应该有一个包罗万象的答案。我觉得这些天我看到的关于Ruby中奇怪行为的几乎所有其他问题都源于这样一个事实，分配没有创建分配对象的副本，只是对它的另一个引用。有点像请在o中编辑问题本身为了使它简洁明了。这个问题应该是独立的，不需要评论来支持。谢谢你的回答。在你提供的例子中，b改为[[1,2]，[1,2]]因为a如果您将一个新对象分配给
a
，那么您就不再谈论插入
b
的同一个
a
。因为它是一个新对象，所以对该新
a
的修改不会影响
b
。
(0..1).collect do |i|
  (0..1).collect do |j|
    j + 100 + i
  end
end