如何在Ruby中复制哈希？

我承认我是一个红宝石新手（现在正在编写rake脚本）。在大多数语言中，复制构造函数很容易找到。半小时的搜索未在红宝石中找到它。我想创建哈希的副本，以便可以修改它而不影响原始实例。

某些预期无法正常工作的方法：

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适用于任何可编组的对象。大多数内置数据类型（数组，哈希，字符串等）都可以编组。

编组是Ruby的序列化名称。通过编组，对象及其引用的对象将转换为一系列字节；这些字节然后用于创建另一个对象，例如原始对象。

如果您使用的是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

我也是Ruby的新手，在复制哈希时遇到了类似的问题。使用以下内容。我不知道这种方法的速度。

copy_of_original_hash = Hash.new.merge(original_hash)

如元帅文档的“安全注意事项”部分所述，

如果需要反序列化不受信任的数据，请使用JSON或另一种只能加载简单的“原始”类型（例如String，Array，Hash等）的序列化格式。

这是一个有关如何在Ruby中使用JSON进行克隆的示例：

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

（令人困惑的是，for的文档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模式散列，其中一些散列是建立在其他散列的基础上的。我最初将它们定义为类变量，然后遇到了这个复制问题。

您可以在下面使用它来深度复制哈希对象。

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

由于Ruby有100万种方法，这是使用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]

由于h2是使用h1的数组表示形式而不是h1的引用形成的，因此产生了deep_copy。