Comment copier un hachage dans Ruby?

J'admets que je suis un peu un débutant rubis (écrit des scripts de râteau, maintenant). Dans la plupart des langues, les constructeurs de copie sont faciles à trouver. Une demi-heure de recherche ne l'a pas trouvée en rubis. Je souhaite créer une copie du hachage afin de pouvoir le modifier sans affecter l'instance d'origine.

Quelques méthodes attendues qui ne fonctionnent pas comme prévu:

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

En attendant, j'ai eu recours à cette solution de contournement inélégante

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

La cloneméthode est la méthode standard et intégrée de Ruby pour effectuer une copie superficielle :

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

Notez que le comportement peut être remplacé:

Cette méthode peut avoir un comportement spécifique à la classe. Si c'est le cas, ce comportement sera documenté sous la #initialize_copyméthode de la classe.

Comme d'autres l'ont souligné, le clonefera. Sachez clonequ'un hachage fait une copie superficielle. C'est-à-dire:

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

Ce qui se passe, c'est que les références du hachage sont copiées, mais pas les objets auxquels elles font référence.

Si vous voulez une copie complète, alors:

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_copyfonctionne pour tout objet pouvant être rassemblé. La plupart des types de données intégrés (Array, Hash, String, etc.) peuvent être rassemblés.

Marshalling est le nom de Ruby pour la sérialisation . Avec le marshaling, l'objet - avec les objets auxquels il fait référence - est converti en une série d'octets; ces octets sont ensuite utilisés pour créer un autre objet comme l'original.

Si vous utilisez Rails, vous pouvez faire:

h1 = h0.deep_dup

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

Hash peut créer un nouveau hachage à partir d'un hachage existant:

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

Je suis également un débutant à Ruby et j'ai rencontré des problèmes similaires lors de la duplication d'un hachage. Utilisez le suivant. Je n'ai aucune idée de la vitesse de cette méthode.

copy_of_original_hash = Hash.new.merge(original_hash)

Comme mentionné dans la section Considérations sur la sécurité de la documentation de Marshal ,

Si vous devez désérialiser des données non fiables, utilisez JSON ou un autre format de sérialisation qui ne peut charger que des types simples et «primitifs» tels que String, Array, Hash, etc.

Voici un exemple sur la façon de cloner à l'aide de JSON dans 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"}

Utilisation Object#clone:

h1 = h0.clone

(Confusément, la documentation de cloneindique que initialize_copyc'est le moyen de contourner cela, mais le lien pour cette méthode Hashvous indique à la replaceplace ...)

Étant donné que la méthode de clonage standard préserve l'état figé, elle ne convient pas pour créer de nouveaux objets immuables basés sur l'objet d'origine, si vous souhaitez que les nouveaux objets soient légèrement différents de l'original (si vous aimez la programmation sans état).

Le clone est lent. Car les performances devraient probablement commencer par un hachage vierge et une fusion. Ne couvre pas le cas des hachages imbriqués ...

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

  système utilisateur de banc total (réel)
  clone 1,960000 0,080000 2,040000 (2,029604)
  fusionner 1,690000 0,080000 1,770000 (1,767828)
  injecter 3.120000 0,030000 3,150000 (3,152627)
  

C'est un cas particulier, mais si vous commencez avec un hachage prédéfini que vous souhaitez récupérer et faire une copie, vous pouvez créer une méthode qui renvoie un hachage:

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

h1 = johns

Le scénario particulier que j'avais était que j'avais une collection de hachages de schéma JSON où certains hachages se sont construits sur d'autres. Je les définissais initialement comme des variables de classe et j'ai rencontré ce problème de copie.

vous pouvez utiliser ci-dessous pour copier en profondeur les objets Hash.

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

Puisque Ruby a un million de façons de le faire, voici une autre façon d'utiliser Enumerable:

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

Une manière alternative à Deep_Copy qui a fonctionné pour moi.

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

Cela a produit une copie profonde puisque h2 est formé en utilisant une représentation matricielle de h1 plutôt que des références de h1.