Ruby конвертувати об'єкт у хеш

Скажімо, у мене є Giftоб’єкт із @name = "book"& @price = 15.95. Який найкращий спосіб перетворити це на хеш {name: "book", price: 15.95}у Ruby, а не на Rails (хоча сміливо дайте відповіді Rails також)?

class Gift
  def initialize
    @name = "book"
    @price = 15.95
  end
end

gift = Gift.new
hash = {}
gift.instance_variables.each {|var| hash[var.to_s.delete("@")] = gift.instance_variable_get(var) }
p hash # => {"name"=>"book", "price"=>15.95}

Як варіант each_with_object:

gift = Gift.new
hash = gift.instance_variables.each_with_object({}) { |var, hash| hash[var.to_s.delete("@")] = gift.instance_variable_get(var) }
p hash # => {"name"=>"book", "price"=>15.95}

Просто скажіть (поточний об’єкт) .attributes

.attributesповертає hashбудь-яку object. І це набагато чистіше.

Здійснювати #to_hash?

class Gift
  def to_hash
    hash = {}
    instance_variables.each { |var| hash[var.to_s.delete('@')] = instance_variable_get(var) }
    hash
  end
end


h = Gift.new("Book", 19).to_hash

Gift.new.instance_values # => {"name"=>"book", "price"=>15.95}

Можна використовувати as_jsonметод. Він перетворить ваш об’єкт у хеш.

Але цей хеш прийде як значення для імені цього об'єкта як ключа. У вашому випадку,

{'gift' => {'name' => 'book', 'price' => 15.95 }}

Якщо вам потрібен хеш, який зберігається в об'єкті використання as_json(root: false). Я думаю, що за замовчуванням root буде хибним. Для отримання додаткової інформації зверніться до офіційного керівництва по рубіну

http://api.rubyonrails.org/classes/ActiveModel/Serializers/JSON.html#method-i-as_json

Для активних об'єктів запису

module  ActiveRecordExtension
  def to_hash
    hash = {}; self.attributes.each { |k,v| hash[k] = v }
    return hash
  end
end

class Gift < ActiveRecord::Base
  include ActiveRecordExtension
  ....
end

class Purchase < ActiveRecord::Base
  include ActiveRecordExtension
  ....
end

а потім просто зателефонуйте

gift.to_hash()
purch.to_hash() 

Якщо ви не перебуваєте в середовищі Rails (тобто не маєте ActiveRecord), це може бути корисним:

JSON.parse( object.to_json )

class Gift
  def to_hash
    instance_variables.map do |var|
      [var[1..-1].to_sym, instance_variable_get(var)]
    end.to_h
  end
end

Можна написати дуже елегантне рішення, використовуючи функціональний стиль.

class Object
  def hashify
    Hash[instance_variables.map { |v| [v.to_s[1..-1].to_sym, instance_variable_get v] }]
  end
end

Вам слід змінити inspectметод вашого об'єкта, щоб повернути потрібний хеш, або просто реалізувати подібний метод, не змінюючи поведінку об'єкта за замовчуванням.

Якщо ви хочете отримати фантазії, ви можете перебирати змінні екземпляри об'єкта за допомогою object.instan_variables

Рекурсивно конвертуйте ваші об'єкти в хеш, використовуючи "hashable" gem ( https://rubygems.org/gems/hashable ) Приклад

class A
  include Hashable
  attr_accessor :blist
  def initialize
    @blist = [ B.new(1), { 'b' => B.new(2) } ]
  end
end

class B
  include Hashable
  attr_accessor :id
  def initialize(id); @id = id; end
end

a = A.new
a.to_dh # or a.to_deep_hash
# {:blist=>[{:id=>1}, {"b"=>{:id=>2}}]}

Ви можете спробувати instance_values. Це працювало для мене.

Створюється неглибока копія як хеш-об’єкт лише атрибутів моделі

my_hash_gift = gift.attributes.dup

Перевірте тип отриманого об'єкта

my_hash_gift.class
=> Hash

Якщо вам потрібні також вкладені вкладені об'єкти.

# @fn       to_hash obj {{{
# @brief    Convert object to hash
#
# @return   [Hash] Hash representing converted object
#
def to_hash obj
  Hash[obj.instance_variables.map { |key|
    variable = obj.instance_variable_get key
    [key.to_s[1..-1].to_sym,
      if variable.respond_to? <:some_method> then
        hashify variable
      else
        variable
      end
    ]
  }]
end # }}}

Gift.new.attributes.symbolize_keys

Щоб зробити це без Rails, чистим способом є збереження атрибутів на постійній основі.

class Gift
  ATTRIBUTES = [:name, :price]
  attr_accessor(*ATTRIBUTES)
end

А потім, щоб перетворити екземпляр Giftдо Hash, ви можете:

class Gift
  ...
  def to_h
    ATTRIBUTES.each_with_object({}) do |attribute_name, memo|
      memo[attribute_name] = send(attribute_name)
    end
  end
end

Це хороший спосіб зробити це, оскільки він буде включати лише те, що ви визначаєте attr_accessor, а не кожну змінну примірника.

class Gift
  ATTRIBUTES = [:name, :price]
  attr_accessor(*ATTRIBUTES)

  def create_random_instance_variable
    @xyz = 123
  end

  def to_h
    ATTRIBUTES.each_with_object({}) do |attribute_name, memo|
      memo[attribute_name] = send(attribute_name)
    end
  end
end

g = Gift.new
g.name = "Foo"
g.price = 5.25
g.to_h
#=> {:name=>"Foo", :price=>5.25}

g.create_random_instance_variable
g.to_h
#=> {:name=>"Foo", :price=>5.25}

Я почав використовувати структури, щоб зробити легкі хеш-конверсії. Замість використання голої структури я створюю власний клас, що виходить з хеша, це дозволяє створювати власні функції, і він документує властивості класу.

require 'ostruct'

BaseGift = Struct.new(:name, :price)
class Gift < BaseGift
  def initialize(name, price)
    super(name, price)
  end
  # ... more user defined methods here.
end

g = Gift.new('pearls', 20)
g.to_h # returns: {:name=>"pearls", :price=>20}