¿Cómo copio un hash en Ruby?

Admito que soy un poco un novato rubí (escribiendo guiones de rake, ahora). En la mayoría de los idiomas, los constructores de copias son fáciles de encontrar. Media hora de búsqueda no lo encontró en rubí. Quiero crear una copia del hash para poder modificarlo sin afectar la instancia original.

Algunos métodos esperados que no funcionan según lo previsto:

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

Mientras tanto, he recurrido a esta solución poco elegante

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

El clonemétodo es la forma estándar incorporada de Ruby para hacer una copia 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"}

Tenga en cuenta que el comportamiento puede ser anulado:

Este método puede tener un comportamiento específico de clase. Si es así, ese comportamiento se documentará según el #initialize_copymétodo de la clase.

Como otros han señalado, clonelo harán. Tenga en cuenta que cloneun 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 las referencias de hash se están copiando, 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_copyfunciona para cualquier objeto que se pueda ordenar. La mayoría de los tipos de datos integrados (Array, Hash, String, etc.) se pueden ordenar.

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

Si está utilizando Rails, puede 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 enfrenté problemas similares al duplicar un hash. Usa 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 la sección Consideraciones de seguridad de la documentación de Marshal ,

Si necesita deserializar datos no confiables, use JSON u otro formato de serialización que solo pueda cargar tipos simples y 'primitivos' 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 clonedice que esa initialize_copyes la forma de anular esto, pero el enlace para ese método lo Hashdirige a usted en su replacelugar ...)

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 al 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

  sistema de usuario de banco total (real)
  clon 1.960000 0.080000 2.040000 (2.029604)
  fusionar 1.690000 0.080000 1.770000 (1.767828)
  inyectar 3.120000 0.030000 3.150000 (3.152627)
  

Este es un caso especial, pero si está comenzando con un hash predefinido que desea obtener 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 se construyeron a partir de otros. Inicialmente los estaba definiendo como variables de clase y me encontré con este problema de copia.

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

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

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

Una forma alternativa de Deep_Copy que funcionó para mí.

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

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