使用对象#克隆:

h1 = h0.clone

(令人困惑的是，clone的文档说initialize_copy是覆盖这个方法的方法，但哈希中该方法的链接指示您替换…)

clone方法是Ruby标准的、内置的浅复制方法:

h0 = {"John" => "Adams", "Thomas" => "Jefferson"}
# => {"John"=>"Adams", "Thomas"=>"Jefferson"}
h1 = h0.clone
# => {"John"=>"Adams", "Thomas"=>"Jefferson"}
h1["John"] = "Smith"
# => "Smith"
h1
# => {"John"=>"Smith", "Thomas"=>"Jefferson"}
h0
# => {"John"=>"Adams", "Thomas"=>"Jefferson"}

注意，行为可能会被覆盖:

该方法可能具有特定于类的行为。如果是，该行为将记录在类的#initialize_copy方法下。

正如其他人指出的，克隆就能做到。请注意，哈希的克隆会产生浅复制。也就是说:

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对序列化的称呼。通过编组，对象及其引用的对象被转换为一系列字节;这些字节随后用于创建与原始对象类似的另一个对象。

你可以使用下面的方法来深度复制哈希对象。

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

哈希可以从一个现有哈希创建一个新的哈希:

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

这是一个特殊的情况，但如果你从一个预定义的哈希开始，你想要获取并复制它，你可以创建一个返回哈希的方法:

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

h1 = johns

我遇到的特殊情况是，我有一个json模式哈希的集合，其中一些哈希建立在其他哈希的基础上。我最初将它们定义为类变量，然后遇到了这个复制问题。

因为Ruby有一百万种方法，这里有另一种使用Enumerable的方法:

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

由于标准克隆方法保留了冻结状态，如果您希望新对象与原始对象略有不同(如果您喜欢无状态编程)，则不适合在原始对象的基础上创建新的不可变对象。

克隆很慢。为了提高性能，应该从空白散列和合并开始。不覆盖嵌套哈希的情况…

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)
  

对我来说，这是Deep_Copy的另一种方法。

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

这产生了一个deep_copy，因为h2是使用h1的数组表示而不是h1的引用形成的。

如果你正在使用Rails，你可以这样做:

h1 = h0.deep_dup

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

我也是Ruby的新手，在复制散列时也遇到过类似的问题。使用下面的方法。我不知道这个方法有多快。

copy_of_original_hash = Hash.new.merge(original_hash)

如Marshal文档的安全考虑部分所述，

如果需要反序列化不受信任的数据，请使用JSON或其他格式 只能加载简单的“原始”的序列化格式 类型，如字符串，数组，哈希等。

下面是一个关于如何在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"}