Bagaimana cara menyalin hash di Ruby?

Saya akan mengakui bahwa saya sedikit pemula yang ruby ​​(menulis skrip menyapu, sekarang). Dalam sebagian besar bahasa, copy constructor mudah ditemukan. Setengah jam pencarian tidak menemukannya di ruby. Saya ingin membuat salinan hash sehingga saya dapat memodifikasinya tanpa memengaruhi instance asli.

Beberapa metode yang diharapkan yang tidak berfungsi sebagaimana dimaksud:

h0 = {  "John"=>"Adams","Thomas"=>"Jefferson","Johny"=>"Appleseed"}
h1=Hash.new(h0)
h2=h1.to_hash

Sementara itu, saya telah menggunakan solusi yang salah ini

def copyhash(inputhash)
  h = Hash.new
  inputhash.each do |pair|
    h.store(pair[0], pair[1])
  end
  return h
end

The cloneMetode standar Ruby, built-in cara untuk melakukan dangkal-copy :

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

Perhatikan bahwa perilaku mungkin diganti:

Metode ini mungkin memiliki perilaku khusus kelas. Jika demikian, perilaku itu akan didokumentasikan di bawah #initialize_copymetode kelas.

Seperti yang telah ditunjukkan orang lain, cloneakan melakukannya. Ketahuilah bahwa clonehash membuat salinan yang dangkal. Artinya:

h1 = {:a => 'foo'} 
h2 = h1.clone
h1[:a] << 'bar'
p h2                # => {:a=>"foobar"}

Apa yang terjadi adalah bahwa referensi hash sedang disalin, tetapi bukan objek yang merujuk referensi.

Jika Anda ingin salinan yang dalam, maka:

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_copybekerja untuk objek apa pun yang dapat disusun. Sebagian besar tipe data bawaan (Array, Hash, String, & c.) Dapat disusun.

Marshalling adalah nama Ruby untuk serialisasi . Dengan marshalling, objek - dengan objek yang dirujuk - dikonversi ke serangkaian byte; byte tersebut kemudian digunakan untuk membuat objek lain seperti aslinya.

Jika Anda menggunakan Rails, Anda dapat melakukannya:

h1 = h0.deep_dup

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

Hash dapat membuat hash baru dari hash yang ada:

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

Saya juga seorang pemula untuk Ruby dan saya menghadapi masalah serupa dalam menduplikasi hash. Gunakan yang berikut ini. Saya tidak tahu tentang kecepatan metode ini.

copy_of_original_hash = Hash.new.merge(original_hash)

Seperti disebutkan di bagian Pertimbangan Keamanan dari dokumentasi Marshal ,

Jika Anda perlu melakukan deserialisasi data yang tidak terpercaya, gunakan JSON atau format serialisasi lain yang hanya dapat memuat tipe 'primitif' sederhana seperti String, Array, Hash, dll.

Berikut adalah contoh cara melakukan kloning menggunakan JSON di Ruby:

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

Gunakan Object#clone:

h1 = h0.clone

(Yang membingungkan, dokumentasi untuk clonemengatakan itu initialize_copyadalah cara untuk menimpanya, tetapi tautan untuk metode itu Hashmengarahkan Anda untuk replacesebaliknya ...)

Karena metode kloning standar mempertahankan keadaan beku, itu tidak cocok untuk membuat objek baru yang tidak dapat diubah berdasarkan objek asli, jika Anda ingin objek baru sedikit berbeda dari yang asli (jika Anda suka pemrograman stateless).

Klon lambat. Untuk kinerja mungkin harus dimulai dengan hash dan penggabungan kosong. Tidak mencakup kasus hash bersarang ...

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

  total sistem pengguna bangku (nyata)
  klon 1.960000 0.080000 2.040000 (2.029604)
  menggabungkan 1,690000 0,080000 1,770000 (1,767828)
  menyuntikkan 3.120000 0.030000 3.150000 (3.152627)
  

Ini adalah kasus khusus, tetapi jika Anda mulai dengan hash yang telah ditentukan yang ingin Anda ambil dan buat salinannya, Anda bisa membuat metode yang mengembalikan hash:

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

h1 = johns

Skenario khusus yang saya miliki adalah saya memiliki koleksi hash-skema JSON di mana beberapa hash dibangun dari yang lain. Saya awalnya mendefinisikan mereka sebagai variabel kelas dan mengalami masalah salinan ini.

Anda dapat menggunakan di bawah ini untuk menyalin objek Hash.

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

Karena Ruby memiliki sejuta cara untuk melakukannya, inilah cara lain menggunakan Enumerable:

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

Cara alternatif untuk Deep_Copy yang bekerja untuk saya.

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

Ini menghasilkan deep_copy karena h2 dibentuk menggunakan representasi array dari referensi h1 daripada h1.