Як скопіювати хеш у Ruby?

Я визнаю, що я трохи рубіновий новачок (зараз пишу граблі-сценарії). У більшості мов конструктори копій легко знайти. Півгодини пошуку не знайшли його в рубіні. Я хочу створити копію хешу, щоб я міг її змінити, не впливаючи на оригінальний екземпляр.

Деякі очікувані методи, які не працюють за призначенням:

h0 = {  "John"=>"Adams","Thomas"=>"Jefferson","Johny"=>"Appleseed"}
h1=Hash.new(h0)
h2=h1.to_hash

Тим часом я вдався до цього нелегального рішення

def copyhash(inputhash)
  h = Hash.new
  inputhash.each do |pair|
    h.store(pair[0], pair[1])
  end
  return h
end

cloneМетод є стандартним в Ruby, вбудований спосіб зробити неглибокий-копію :

irb(main):003:0> h0 = {"John" => "Adams", "Thomas" => "Jefferson"}
=> {"John"=>"Adams", "Thomas"=>"Jefferson"}
irb(main):004:0> h1 = h0.clone
=> {"John"=>"Adams", "Thomas"=>"Jefferson"}
irb(main):005:0> h1["John"] = "Smith"
=> "Smith"
irb(main):006:0> h1
=> {"John"=>"Smith", "Thomas"=>"Jefferson"}
irb(main):007:0> h0
=> {"John"=>"Adams", "Thomas"=>"Jefferson"}

Зауважте, що поведінка може бути відмінена:

Цей метод може мати поведінку, що залежить від класу. Якщо так, то така поведінка буде задокументована #initialize_copyметодом класу.

Як вказували інші, cloneце зроблять. Майте на увазі, що cloneхеш робить дрібну копію. Тобто:

h1 = {:a => 'foo'} 
h2 = h1.clone
h1[:a] << 'bar'
p h2                # => {:a=>"foobar"}

Що відбувається, так це те, що копії посилань хешу копіюються, але не об'єкти, на які посилаються посилання.

Якщо ви хочете отримати глибоку копію, виконайте вказані нижче дії.

def deep_copy(o)
  Marshal.load(Marshal.dump(o))
end

h1 = {:a => 'foo'}
h2 = deep_copy(h1)
h1[:a] << 'bar'
p h2                # => {:a=>"foo"}

deep_copyпрацює для будь-якого об'єкта, який може бути маршований. Більшість вбудованих типів даних (Array, Hash, String та ін.) Можуть бути скасовані.

Маршаллінг - ім'я Рубі для серіалізації . При маршируванні об'єкт - з об'єктами, на які він посилається - перетворюється на ряд байтів; ці байти потім використовуються для створення іншого об'єкта, такого як оригінал.

Якщо ви використовуєте Rails, ви можете:

h1 = h0.deep_dup

http://apidock.com/rails/Hash/deep_dup

Хеш може створити новий хеш із наявного хешу:

irb(main):009:0> h1 = {1 => 2}
=> {1=>2}
irb(main):010:0> h2 = Hash[h1]
=> {1=>2}
irb(main):011:0> h1.object_id
=> 2150233660
irb(main):012:0> h2.object_id
=> 2150205060

Я також новачок Рубі, і у мене виникли подібні проблеми при копіюванні хеша. Скористайтеся наступним. Я не маю поняття про швидкість цього методу.

copy_of_original_hash = Hash.new.merge(original_hash)

Як згадується в розділі "Безпечні питання" документації маршала ,

Якщо вам потрібно десаріалізувати недовірені дані, використовуйте JSON або інший формат серіалізації, який може завантажувати лише прості, примітивні типи, такі як String, Array, Hash тощо.

Ось приклад того, як зробити клонування за допомогою JSON в Ruby:

require "json"

original = {"John"=>"Adams","Thomas"=>"Jefferson","Johny"=>"Appleseed"}
cloned = JSON.parse(JSON.generate(original))

# Modify original hash
original["John"] << ' Sandler'
p original 
#=> {"John"=>"Adams Sandler", "Thomas"=>"Jefferson", "Johny"=>"Appleseed"}

# cloned remains intact as it was deep copied
p cloned  
#=> {"John"=>"Adams", "Thomas"=>"Jefferson", "Johny"=>"Appleseed"}

Використання Object#clone:

h1 = h0.clone

(Конфузно, документація для cloneговорить про те, що initialize_copyце спосіб перекрити це, але посилання на цей метод Hashспрямовує вас на те, щоб replaceзамість цього ...)

Оскільки стандартний метод клонування зберігає заморожений стан, він не підходить для створення нових незмінних об'єктів на основі оригінального об'єкта, якщо ви хочете, щоб нові об'єкти були дещо іншими, ніж оригінальні (якщо вам подобається програмування без стану).

Клон повільний. Для продуктивності, мабуть, слід починати з порожнього хешу та злиття. Не охоплює регістр вкладених хешей ...

require 'benchmark'

def bench  Benchmark.bm do |b|    
    test = {'a' => 1, 'b' => 2, 'c' => 3, 4 => 'd'}
    b.report 'clone' do
      1_000_000.times do |i|
        h = test.clone
        h['new'] = 5
      end
    end
    b.report 'merge' do
      1_000_000.times do |i|
        h = {}
        h['new'] = 5
        h.merge! test
      end
    end
    b.report 'inject' do
      1_000_000.times do |i|
        h = test.inject({}) do |n, (k, v)|
          n[k] = v;
          n
        end
        h['new'] = 5
      end
    end
  end
end

  система користувальницької лавки загальна (реальна)
  клон 1,960000 0,080000 2,040000 (2,029604)
  злиття 1,690000 0,080000 1,770000 (1,767828)
  вводити 3.120000 0.030000 3.150000 (3.152627)
  

Це особливий випадок, але якщо ви починаєте з заздалегідь заданого хешу, який потрібно захопити та зробити копію, ви можете створити метод, який повертає хеш:

def johns 
    {  "John"=>"Adams","Thomas"=>"Jefferson","Johny"=>"Appleseed"}
end

h1 = johns

Конкретний сценарій, який у мене був, у мене була колекція хешей JSON-схем, де одні хеші створювали інші. Я спочатку визначав їх як змінні класу і стикався з цією проблемою копіювання.

ви можете використовувати нижче для глибокої копіювання об'єктів Hash.

deeply_copied_hash = Marshal.load(Marshal.dump(original_hash))

Оскільки у Ruby є мільйон способів це зробити, ось ще один спосіб використання Enumerable:

h0 = {  "John"=>"Adams","Thomas"=>"Jefferson","Johny"=>"Appleseed"}
h1 = h0.inject({}) do |new, (name, value)| 
    new[name] = value;
    new 
end

Альтернативний спосіб Deep_Copy, який працював на мене.

h1 = {:a => 'foo'} 
h2 = Hash[h1.to_a]

Це створило deep_copy, оскільки h2 формується з використанням представлення масиву h1, а не посилань на h1.