Como copiar um hash no Ruby?

Admito que sou um pouco novato em rubi (agora estou escrevendo scripts de rake). Na maioria dos idiomas, os construtores de cópias são fáceis de encontrar. Meia hora de busca não encontrou em rubi. Quero criar uma cópia do hash para poder modificá-lo sem afetar a instância original.

Alguns métodos esperados que não funcionam conforme o esperado:

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

Enquanto isso, eu recorri a essa solução deselegante

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

O clonemétodo é o padrão de Ruby, maneira integrada de fazer uma cópia superficial :

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"}

Observe que o comportamento pode ser substituído:

Este método pode ter um comportamento específico da classe. Nesse caso, esse comportamento será documentado sob o #initialize_copymétodo da classe.

Como outros já apontaram, clonefarão isso. Esteja ciente de que cloneum hash faz uma cópia superficial. Ou seja:

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

O que está acontecendo é que as referências do hash estão sendo copiadas, mas não os objetos aos quais as referências se referem.

Se você deseja uma cópia profunda, então:

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_copyfunciona para qualquer objeto que possa ser empacotado. A maioria dos tipos de dados internos (matriz, hash, cadeia etc.) pode ser empacotada.

Marshalling é o nome de Ruby para serialização . Com o empacotamento, o objeto - com os objetos a que se refere - é convertido em uma série de bytes; esses bytes são usados ​​para criar outro objeto como o original.

Se você estiver usando o Rails, poderá:

h1 = h0.deep_dup

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

O hash pode criar um novo hash a partir de um hash existente:

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

Também sou novato no Ruby e enfrentei problemas semelhantes ao duplicar um hash. Use o seguinte. Não faço ideia da velocidade desse método.

copy_of_original_hash = Hash.new.merge(original_hash)

Conforme mencionado na seção Considerações de segurança da documentação do Marshal ,

Se você precisar desserializar dados não confiáveis, use JSON ou outro formato de serialização capaz de carregar apenas tipos "primitivos" simples, como String, Array, Hash etc.

Aqui está um exemplo de como fazer clonagem usando JSON no 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"}

Use Object#clone:

h1 = h0.clone

(Confusamente, a documentação para clonediz que initialize_copyé a maneira de substituir isso, mas o link para esse método no Hashdireciona você a replacesubstituir ...)

Como o método de clonagem padrão preserva o estado congelado, não é adequado para criar novos objetos imutáveis ​​com base no objeto original, se você desejar que os novos objetos sejam ligeiramente diferentes do original (se você gosta de programação sem estado).

O clone é lento. Pois o desempenho provavelmente deve começar com o hash e a mesclagem em branco. Não abrange casos de hashes aninhados ...

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

  total do sistema do usuário do banco (real)
  clone 1,960000 0,080000 2,040000 (2,029604)
  mesclar 1,690000 0,080000 1,770000 (1,767828)
  injetar 3,120000 0,030000 3,150000 (3,152627)
  

Este é um caso especial, mas se você estiver começando com um hash predefinido que deseja pegar e fazer uma cópia, poderá criar um método que retorne um hash:

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

h1 = johns

O cenário particular que eu tive foi que eu tinha uma coleção de hashes de esquema JSON onde alguns hashes foram construídos a partir de outros. Inicialmente, eu as defini como variáveis ​​de classe e me deparei com esse problema de cópia.

você pode usar abaixo para copiar objetos Hash em profundidade.

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

Como o Ruby tem um milhão de maneiras de fazer isso, aqui está outra maneira de usar o Enumerable:

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

Maneira alternativa ao Deep_Copy que funcionou para mim.

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

Isso produziu uma cópia_ profunda, já que h2 é formado usando uma representação de matriz de h1 em vez das referências de h1.