我承认我是一位Ruby新手（目前正在编写rake脚本）。在大多数语言中，复制构造函数很容易找到。但在Ruby中，我搜索了半个小时也没有找到。我想创建哈希表的副本，以便我可以修改它而不影响原始实例。
以下是一些预期不起作用的方法：
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内置的标准方法，用于执行浅复制 (shallow-copy)：
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方法下记录。
Marshal.load(Marshal.dump(h))。 - bheeshmarclone而不是dup？在这种情况下，您需要复制单例类吗？https://dev59.com/FGkw5IYBdhLWcg3wBmGA - Sim正如其他人所指出的，clone可以实现这一点。请注意，对哈希表（hash）进行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适用于可被序列化的任何对象。大多数内置数据类型（例如Array、Hash、String等）都可以被序列化。
序列化（Marshalling）是Ruby中用来表示序列化的术语。通过序列化，对象以及它所引用的其他对象将会被转换为一系列字节，这些字节随后将被用于创建与原始对象相似的另一个对象。
Marshal.load(Marshal.dump(o)) 究竟是如何进行深度复制的？我真的不太理解背后发生了什么。 - Muntasir Alamh1[:a] << 'bar'，你会修改原始对象（即 h1[:a] 指向的字符串），但是如果你执行 h1[:a] = "#{h1[:a]}bar"，你将创建一个新的字符串对象，并将 h1[:a] 指向它，而 h2[:a] 仍然指向旧的（未修改的）字符串。 - Max WilliamsMarshal.load的输入不可信，则为真，并且要记住的一个好警告。 在这种情况下，它的输入来自我们自己进程中的Marshal.dump。 我认为在这种情况下，Marshal.load是安全的。 - Wayne ConradHash可以从现有的哈希创建新的哈希：
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
正如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"}
我也是Ruby的新手，曾经遇到过复制哈希表的问题。可以使用以下方法进行复制，但我不知道这种方法的速度如何。
copy_of_original_hash = Hash.new.merge(original_hash)
请使用Object#clone方法：
h1 = h0.clone
clone的文档说要重写initialize_copy，但在Hash中该方法的链接却将您导向replace...）这是一个特殊情况，但如果您要从预定义的哈希开始并复制它，您可以创建一个返回哈希的方法：
def johns
{ "John"=>"Adams","Thomas"=>"Jefferson","Johny"=>"Appleseed"}
end
h1 = johns
克隆速度较慢。为了提高性能，可能应该从空哈希表开始并合并。不涵盖嵌套哈希表的情况...
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)
Hash对象，提供的答案是很好的。但如果你正在处理来自你无法控制的类似Hash的对象，你应该考虑是否要复制与Hash相关联的单例类。请参见https://dev59.com/FGkw5IYBdhLWcg3wBmGA。 - Sim