¿Cómo copio un hash en Ruby?

Como otros han señalado, clone lo hará. Tenga en cuenta que clone de un hash hace una copia superficial. Es decir:

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

Lo que sucede es que se están copiando las referencias del hash, pero no los objetos a los que se refieren las referencias.

Si quieres una copia profunda entonces:

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 funciona para cualquier objeto que puede calcularse. La mayoría de los tipos de datos incorporados (Array, Hash, String, &c.) pueden ser marshalled.

Marshalling es el nombre de Ruby para serialización. Con marshalling, el objeto--con los objetos a los que se refiere is se convierte en una serie de bytes; esos bytes se utilizan para crear otro objeto como el original.

Si estás usando Rails puedes hacer:

h1 = h0.deep_dup

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

Hash puede crear un nuevo hash a partir de un 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

También soy un novato en Ruby y me enfrenté a problemas similares al duplicar un hash. Utilice lo siguiente. No tengo idea de la velocidad de este método.

copy_of_original_hash = Hash.new.merge(original_hash)

Como se menciona en Sección de Consideraciones de seguridad de documentación Marshal ,

Si necesita deserializar datos no confiables, use JSON u otro formato de serialización que solo es capaz de cargar simple, 'primitivo' tipos como String, Array, Hash, etc.

Aquí hay un ejemplo sobre cómo hacer clonación usando JSON en 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"}

Uso Object#clone:

h1 = h0.clone

(Confusamente, la documentación para clone dice que initialize_copy es la forma de anular esto, pero el enlace para ese método en Hash te dirige a replace en su lugar...)

Puede usar a continuación para copiar objetos Hash en profundidad.

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

Dado que el método de clonación estándar conserva el estado congelado, no es adecuado para crear nuevos objetos inmutables basados en el objeto original, si desea que los nuevos objetos sean ligeramente diferentes del original (si le gusta la programación sin estado).

El clon es lento. Para el rendimiento probablemente debería comenzar con hash en blanco y fusionar. No cubre el caso de hashes anidados...

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

  bench  user      system      total        ( real)
  clone  1.960000   0.080000    2.040000    (  2.029604)
  merge  1.690000   0.080000    1.770000    (  1.767828)
  inject 3.120000   0.030000    3.150000    (  3.152627)
  

Dado que Ruby tiene un millón de formas de hacerlo, aquí hay otra forma de usar Enumerable:

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

Este es un caso especial, pero si está comenzando con un hash predefinido del que desea tomar y hacer una copia, puede crear un método que devuelva un hash:

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

h1 = johns

El escenario particular que tuve fue que tenía una colección de hashes de esquema JSON donde algunos hashes construyeron otros. Inicialmente las estaba definiendo como variables de clase y me encontré con este problema de copia.

Forma alternativa a Deep_Copy que funcionó para mí.

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

Esto produjo un deep_copy ya que h2 se forma usando una representación de matriz de h1 en lugar de las referencias de h1.