[英]How do I copy a hash in 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
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
方法下。
正如其他人指出的那样, 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
适用于任何可以编组的对象。 大多数内置数据类型(数组、哈希、字符串等)都可以编组。
Marshalling是 Ruby 对序列化的称呼。 通过编组,对象——连同它所指的对象——被转换为一系列字节; 然后使用这些字节创建另一个像原始对象一样的对象。
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
如果您需要反序列化不受信任的数据,请使用 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
我遇到的特殊情况是我有一组 JSON 模式哈希,其中一些哈希建立在其他哈希之上。 我最初将它们定义为类变量并遇到了这个复制问题。
由于标准克隆方法保留了冻结状态,因此不适合基于原始对象创建新的不可变对象,如果您希望新对象与原始对象略有不同(如果您喜欢无状态编程)。
克隆很慢。 为了提高性能,可能应该从空白哈希和合并开始。 不包括嵌套哈希的情况......
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)
由于 Ruby 有一百万种方法可以做到这一点,这里有另一种使用 Enumerable 的方法:
h0 = { "John"=>"Adams","Thomas"=>"Jefferson","Johny"=>"Appleseed"}
h1 = h0.inject({}) do |new, (name, value)|
new[name] = value;
new
end
您可以使用下面的深度复制 Hash 对象。
deeply_copied_hash = Marshal.load(Marshal.dump(original_hash))
对我有用的 Deep_Copy 的替代方法。
h1 = {:a => 'foo'}
h2 = Hash[h1.to_a]
这产生了一个 deep_copy,因为 h2 是使用 h1 的数组表示而不是 h1 的引用形成的。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.