如何在 Ruby 中復制哈希？

Question

我承認我有點像紅寶石新手（現在正在編寫 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

Answer 1

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方法下。

Answer 2

正如其他人指出的那樣， 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 對序列化的稱呼。 通過編組，對象——連同它所指的對象——被轉換為一系列字節； 然后使用這些字節創建另一個像原始對象一樣的對象。

Answer 3

如果你使用 Rails，你可以這樣做：

h1 = h0.deep_dup

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

Answer 4

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

Answer 5

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

Answer 6

我也是 Ruby 的新手，我在復制哈希時遇到了類似的問題。 使用以下內容。 我不知道這種方法的速度。

copy_of_original_hash = Hash.new.merge(original_hash)

Answer 7

使用Object#clone ：

h1 = h0.clone

（令人困惑的是， clone的文檔說initialize_copy是覆蓋它的方法，但是Hash中該方法的鏈接會指示您replace ...）

Answer 8

這是一種特殊情況，但如果您從要獲取並復制的預定義哈希開始，您可以創建一個返回哈希的方法：

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

h1 = johns

我遇到的特殊情況是我有一組 JSON 模式哈希，其中一些哈希建立在其他哈希之上。 我最初將它們定義為類變量並遇到了這個復制問題。

Answer 9

由於標准克隆方法保留了凍結狀態，因此不適合基於原始對象創建新的不可變對象，如果您希望新對象與原始對象略有不同（如果您喜歡無狀態編程）。

Answer 10

克隆很慢。 為了提高性能，可能應該從空白哈希和合並開始。 不包括嵌套哈希的情況......

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)

Answer 11

由於 Ruby 有一百萬種方法可以做到這一點，這里有另一種使用 Enumerable 的方法：

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

Answer 12

您可以使用下面的深度復制 Hash 對象。

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

Answer 13

對我有用的 Deep_Copy 的替代方法。

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

這產生了一個 deep_copy，因為 h2 是使用 h1 的數組表示而不是 h1 的引用形成的。