Làm cách nào để sao chép hàm băm trong Ruby?

Tôi sẽ thừa nhận rằng tôi là một người mới chơi ruby ​​(viết kịch bản cào, bây giờ). Trong hầu hết các ngôn ngữ, các hàm tạo sao chép rất dễ tìm. Nửa giờ tìm kiếm đã không tìm thấy nó trong ruby. Tôi muốn tạo một bản sao của hàm băm để tôi có thể sửa đổi nó mà không ảnh hưởng đến thể hiện ban đầu.

Một số phương pháp dự kiến ​​không hoạt động như dự định:

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

Trong khi đó, tôi đã dùng đến cách giải quyết không phù hợp này

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

Các clonephương pháp là tiêu chuẩn của Ruby, được xây dựng theo cách để làm một nông-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"}

Lưu ý rằng hành vi có thể bị ghi đè:

Phương pháp này có thể có hành vi cụ thể của lớp. Nếu vậy, hành vi đó sẽ được ghi lại theo #initialize_copyphương thức của lớp.

Như những người khác đã chỉ ra, clonesẽ làm điều đó. Hãy nhận biết rằng clonebăm tạo ra một bản sao nông. Điều đó có nghĩa là:

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

Điều đang xảy ra là các tham chiếu của hàm băm đang được sao chép, nhưng không phải là các đối tượng mà các tham chiếu tham chiếu đến.

Nếu bạn muốn có một bản sao sâu thì:

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_copylàm việc cho bất kỳ đối tượng có thể được sắp xếp theo thứ tự. Hầu hết các kiểu dữ liệu tích hợp (Array, Hash, String, & c.) Có thể được sắp xếp theo thứ tự.

Marshalling là tên của Ruby để tuần tự hóa . Với marshalling, đối tượng - với các đối tượng mà nó đề cập - được chuyển đổi thành một chuỗi byte; những byte đó sau đó được sử dụng để tạo một đối tượng khác giống như bản gốc.

Nếu bạn đang sử dụng Rails, bạn có thể làm:

h1 = h0.deep_dup

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

Hash có thể tạo một hàm băm mới từ hàm băm hiện có:

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

Tôi cũng là người mới chơi Ruby và tôi gặp phải vấn đề tương tự khi sao chép hàm băm. Sử dụng như sau. Tôi không biết gì về tốc độ của phương pháp này.

copy_of_original_hash = Hash.new.merge(original_hash)

Như đã đề cập trong phần Xem xét bảo mật của tài liệu Nguyên soái ,

Nếu bạn cần giải tuần tự hóa dữ liệu không đáng tin cậy, hãy sử dụng JSON hoặc định dạng tuần tự hóa khác chỉ có thể tải các loại đơn giản, 'nguyên thủy' như String, Array, Hash, v.v.

Dưới đây là một ví dụ về cách thực hiện nhân bản bằng JSON trong 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"}

Sử dụng Object#clone:

h1 = h0.clone

(Thật khó hiểu, tài liệu cho clonebiết đó initialize_copylà cách để ghi đè lên điều này, nhưng liên kết cho phương thức đó để Hashhướng dẫn bạn replacethay vào đó ...)

Vì phương pháp nhân bản tiêu chuẩn duy trì trạng thái đóng băng, không phù hợp để tạo các đối tượng bất biến mới dựa trên đối tượng ban đầu, nếu bạn muốn các đối tượng mới sẽ hơi khác so với ban đầu (nếu bạn thích lập trình không trạng thái).

Bản sao chậm. Đối với hiệu suất có lẽ nên bắt đầu với băm trống và hợp nhất. Không bao gồm trường hợp băm lồng nhau ...

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

  tổng số hệ thống người dùng (thực)
  nhân bản 1.960000 0.080000 2.040000 (2.029604)
  hợp nhất 1.690000 0.080000 1.770000 (1.767828)
  tiêm 3.120000 0.030000 3.150000 (3.152627)
  

Đây là trường hợp đặc biệt, nhưng nếu bạn bắt đầu với hàm băm được xác định trước mà bạn muốn lấy và tạo một bản sao, bạn có thể tạo một phương thức trả về hàm băm:

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

h1 = johns

Kịch bản cụ thể mà tôi có là tôi đã có một bộ băm lược đồ JSON trong đó một số băm được tạo ra từ những cái khác. Ban đầu tôi đã định nghĩa chúng là các biến lớp và gặp vấn đề sao chép này.

bạn có thể sử dụng bên dưới để sao chép sâu các đối tượng Hash.

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

Vì Ruby có hàng triệu cách để làm điều đó, đây là một cách khác bằng cách sử dụng Enumerable:

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

Cách khác để Deep_Copy làm việc cho tôi.

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

Điều này tạo ra một deep_copy vì h2 được hình thành bằng cách sử dụng một đại diện mảng của h1 thay vì tham chiếu của h1.