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

Для объектов Active Record

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.instance_variables

Рекурсивно преобразуйте ваши объекты в хэш с помощью хешируемого гема ( 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в a 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}