Ruby 将一个数组设置为另一个数组，然后在不影响第二个数组的情况下更改第一个数组

我有一个数组'a'，后来我将一个新数组'b'设置为'a'。当我从任一数组中删除一个元素时，它们都会更改，而不是显式引用的数组。我认为这是因为它们指向同一个底层对象

a= ["cat","hat","dog"]
b= a
a.delete_at(0)
print a
>> a = ["hat","dog"
print b
>> b = ["hat","dog"]

如何将两个变量设置为相等，但允许它们在以后的操作中独立？我在寻找这样的行为：

a= ["cat","hat","dog"]
b= a
a.delete_at(0)
print a
>> a = ["hat","dog"
print b
>> b = ["cat","hat","dog"]

用于创建原始阵列的副本：

a = ["cat","hat","dog"]
b = a.dup # b now points to a duplicate of a, not a itself

b # => ["cat","hat","dog"]
b.delete_at(0)

b # => ["hat","dog"]
a # => ["cat","hat","dog"]

要验证此行为，请执行以下操作：

a = [1, 2, 3]
b = a
a.object_id == b.object_id # => true, a and b point to the same objects

a = [1, 2, 3]
b = a.dup
a.object_id == b.object_id # => false, a and b point to different objects

用于创建原始阵列的副本：

a = ["cat","hat","dog"]
b = a.dup # b now points to a duplicate of a, not a itself

b # => ["cat","hat","dog"]
b.delete_at(0)

b # => ["hat","dog"]
a # => ["cat","hat","dog"]

要验证此行为，请执行以下操作：

a = [1, 2, 3]
b = a
a.object_id == b.object_id # => true, a and b point to the same objects

a = [1, 2, 3]
b = a.dup
a.object_id == b.object_id # => false, a and b point to different objects

用于创建原始阵列的副本：

a = ["cat","hat","dog"]
b = a.dup # b now points to a duplicate of a, not a itself

b # => ["cat","hat","dog"]
b.delete_at(0)

b # => ["hat","dog"]
a # => ["cat","hat","dog"]

要验证此行为，请执行以下操作：

a = [1, 2, 3]
b = a
a.object_id == b.object_id # => true, a and b point to the same objects

a = [1, 2, 3]
b = a.dup
a.object_id == b.object_id # => false, a and b point to different objects

用于创建原始阵列的副本：

a = ["cat","hat","dog"]
b = a.dup # b now points to a duplicate of a, not a itself

b # => ["cat","hat","dog"]
b.delete_at(0)

b # => ["hat","dog"]
a # => ["cat","hat","dog"]

要验证此行为，请执行以下操作：

a = [1, 2, 3]
b = a
a.object_id == b.object_id # => true, a and b point to the same objects

a = [1, 2, 3]
b = a.dup
a.object_id == b.object_id # => false, a and b point to different objects

---

也许值得注意的是，如果

a = [["cat", "pig"], "hat", "dog"] # => [["cat", "pig"], "hat", "dog"]
b = a.dup                          # => [["cat", "pig"], "hat", "dog"]

然后

在这里，您需要执行以下操作：

a = [["cat", "pig"], "hat", "dog"]
b = a.dup 
b[0] = a[0].dup
a[0].delete_at(0)
a                                  # => [["pig"], "hat", "dog"] 
b                                  # => [["cat", "pig"], "hat", "dog"] 

现在假设

a

要复杂得多，比如说，一个散列数组，其值是散列数组。显然，在制作

a

的副本时必须小心，因为删除

a

的某些深层嵌套元素不会影响该副本。你想要的是所谓的“深拷贝”，而不是由和制作的“浅拷贝”

幸运的是，有一种简单的方法可以使用和制作任何对象的深度副本：

另一方面，

封送处理

还用于将对象保存到文件以供以后检索：

File.open('myfile', 'w+') do |f|  
  Marshal.dump(a, f)  
end  

File.open('myfile') do |f|  
  c = Marshal.load(f)  
end  
c                                  #  => [["cat", "pig"], "hat", "dog"]

---

警告：封送处理文件不是所有Ruby版本都可以移植的。

也许值得注意的是，如果

a = [["cat", "pig"], "hat", "dog"] # => [["cat", "pig"], "hat", "dog"]
b = a.dup                          # => [["cat", "pig"], "hat", "dog"]

然后

在这里，您需要执行以下操作：

a = [["cat", "pig"], "hat", "dog"]
b = a.dup 
b[0] = a[0].dup
a[0].delete_at(0)
a                                  # => [["pig"], "hat", "dog"] 
b                                  # => [["cat", "pig"], "hat", "dog"] 

现在假设

a

要复杂得多，比如说，一个散列数组，其值是散列数组。显然，在制作

a

的副本时必须小心，因为删除

a

的某些深层嵌套元素不会影响该副本。你想要的是所谓的“深拷贝”，而不是由和制作的“浅拷贝”

幸运的是，有一种简单的方法可以使用和制作任何对象的深度副本：

另一方面，

封送处理

还用于将对象保存到文件以供以后检索：

File.open('myfile', 'w+') do |f|  
  Marshal.dump(a, f)  
end  

File.open('myfile') do |f|  
  c = Marshal.load(f)  
end  
c                                  #  => [["cat", "pig"], "hat", "dog"]

---

警告：封送处理文件不是所有Ruby版本都可以移植的。

也许值得注意的是，如果

a = [["cat", "pig"], "hat", "dog"] # => [["cat", "pig"], "hat", "dog"]
b = a.dup                          # => [["cat", "pig"], "hat", "dog"]

然后

在这里，您需要执行以下操作：

a = [["cat", "pig"], "hat", "dog"]
b = a.dup 
b[0] = a[0].dup
a[0].delete_at(0)
a                                  # => [["pig"], "hat", "dog"] 
b                                  # => [["cat", "pig"], "hat", "dog"] 

现在假设

a

要复杂得多，比如说，一个散列数组，其值是散列数组。显然，在制作

a

的副本时必须小心，因为删除

a

的某些深层嵌套元素不会影响该副本。你想要的是所谓的“深拷贝”，而不是由和制作的“浅拷贝”

幸运的是，有一种简单的方法可以使用和制作任何对象的深度副本：

另一方面，

封送处理

还用于将对象保存到文件以供以后检索：

File.open('myfile', 'w+') do |f|  
  Marshal.dump(a, f)  
end  

File.open('myfile') do |f|  
  c = Marshal.load(f)  
end  
c                                  #  => [["cat", "pig"], "hat", "dog"]

---

警告：封送处理文件不是所有Ruby版本都可以移植的。

也许值得注意的是，如果

a = [["cat", "pig"], "hat", "dog"] # => [["cat", "pig"], "hat", "dog"]
b = a.dup                          # => [["cat", "pig"], "hat", "dog"]

然后

在这里，您需要执行以下操作：

a = [["cat", "pig"], "hat", "dog"]
b = a.dup 
b[0] = a[0].dup
a[0].delete_at(0)
a                                  # => [["pig"], "hat", "dog"] 
b                                  # => [["cat", "pig"], "hat", "dog"] 

现在假设

a

要复杂得多，比如说，一个散列数组，其值是散列数组。显然，在制作

a

的副本时必须小心，因为删除

a

的某些深层嵌套元素不会影响该副本。你想要的是所谓的“深拷贝”，而不是由和制作的“浅拷贝”

幸运的是，有一种简单的方法可以使用和制作任何对象的深度副本：

另一方面，

封送处理

还用于将对象保存到文件以供以后检索：

File.open('myfile', 'w+') do |f|  
  Marshal.dump(a, f)  
end  

File.open('myfile') do |f|  
  c = Marshal.load(f)  
end  
c                                  #  => [["cat", "pig"], "hat", "dog"]

注意：封送处理文件并非在所有版本的Ruby中都可移植。

我刚刚注意到，在执行字符串操作时，“DUP”方法不起作用。例如，如果我执行b[0]，则为upcase！两个数组的第一个元素都已更改。有什么见解吗？我刚刚注意到，在进行字符串操作时，“DUP”方法不起作用。例如，如果我执行b[0]，则为upcase！两个数组的第一个元素都已更改。有什么见解吗？我刚刚注意到，在进行字符串操作时，“DUP”方法不起作用。例如，如果我执行b[0]，则为upcase！两个数组的第一个元素都已更改。有什么见解吗？我刚刚注意到，在进行字符串操作时，“DUP”方法不起作用。例如，如果我执行b[0]，则为upcase！两个数组的第一个元素都已更改。对此有什么见解吗？