В чем разница между «input = self» и «input = self.dup»

Question

Так что проблема, с которой я столкнулась, заключается в понимании разницы между = self и = self dup. Когда я запускаю код ниже любого массива, который я вставляю в него, он постоянно изменяется.

class Array 
    def pad(min_size, value = nil) 
    input = self 
    counter = min_size.to_i - self.length.to_i 
    counter.times do 
     input.push(value) 
    end 
    input 
    end 
end 

Но потом я заметил, если я ставлю input = self.dup не будет постоянно менять свой массив. Может кто-нибудь объяснить, почему? Благодаря!

class Array 
    def pad(min_size, value = nil) 
    input = self.dup 
    counter = min_size.to_i - self.length.to_i 
    counter.times do 
     input.push(value) 
    end 
    input 
    end 
end 

Answer 1

Проверьте их object_id, который даст вам ответ, говоря, что self и self#dup являются 2 другим объектом.

class Array 
    def dummy 
    [self.object_id,self.dup.object_id] 
    end 
    def add 
    [self.push(5),self.dup.push(5)] 
    end 
end 

a = [12,11] 
a.dummy # => [80922410, 80922400] 
a.add # => [[12, 11, 5], [12, 11, 5, 5]] 
a # => [12, 11, 5] 

Answer 2

Поскольку self.dup возвращает неполную копию массива и поэтому код не изменит массив постоянно.

Reference

Answer 3

Когда вы сделали дубликат вашего массива, вы в конечном итоге с двумя отдельными массивами, которые имели одни и те же элементы в них, как в этом примере:

x = [1, 2, 3] 
y = [1, 2, 3] 

x << 4 
p x 
p y 

--output:-- 
[1, 2, 3, 4] 
[1, 2, 3] 

Вы бы не ожидать изменений в массив x влияет на массив y, не так ли? Аналогичным образом:

arr = [1, 2, 3] 
puts "arr = #{arr}"  #arr = [1, 2, 3 

copy = arr.dup 
puts "copy = #{copy}" #copy = [1, 2, 3] 

arr << 4 
puts "arr = #{arr}"  #arr = [1, 2, 3, 4] 
puts "copy = #{copy}" #copy = [1, 2, 3] 

copy << "hello" 
puts "arr = #{arr}"  #arr = [1, 2, 3, 4] 
puts "copy = #{copy}" #copy = [1, 2, 3, "hello"] 

В этом примере arr играет роль self, а копия играет роль self.dup. Массивы self и self.dup представляют собой разные массивы, которые имеют одинаковые элементы.

Массив может иметь неограниченное число переменных, которые относятся к нему:

arr = [1, 2, 3] 
puts "arr = #{arr}" #arr = [1, 2, 3] 

input = arr 
input << 4 
puts "arr = #{arr}" #arr = [1, 2, 3, 4] 

Теперь давайте вход ссылаться на другой массив:

copy = arr.dup 
input = copy 
input << "hello" 

puts "copy = #{copy}" #copy = [1, 2, 3, 4, "hello"] 
puts "input = #{input}" #input = [1, 2, 3, 4, "hello"] 
puts "arr = #{arr}"  #arr = [1, 2, 3, 4]