Ruby converte Objeto em Hash

Digamos que eu tenho um Giftobjeto com @name = "book"& @price = 15.95. Qual é a melhor maneira de converter isso para o Hash {name: "book", price: 15.95}em Ruby, não para o Rails (embora fique à vontade para dar a resposta do Rails também)?

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}

Alternativamente com 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}

Apenas diga (objeto atual) .attributes

.attributesretorna um hashde qualquer object. E é muito mais limpo também.

Implementar #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}

Você pode usar o as_jsonmétodo Ele converterá seu objeto em hash.

Mas, esse hash será um valor para o nome desse objeto como uma chave. No seu caso,

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

Se você precisar de um hash armazenado no objeto use as_json(root: false). Eu acho que por padrão a raiz será falsa. Para mais informações, consulte o guia oficial do ruby

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

Para objetos de registro ativo

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

e depois é só ligar

gift.to_hash()
purch.to_hash() 

Se você não está em um ambiente Rails (ou seja, não possui o ActiveRecord disponível), isso pode ser útil:

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

Você pode escrever uma solução muito elegante usando um estilo funcional.

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

Você deve substituir o inspectmétodo do seu objeto para retornar o hash desejado ou apenas implementar um método semelhante sem substituir o comportamento padrão do objeto.

Se você quiser ficar mais sofisticado, pode iterar sobre as variáveis ​​de instância de um objeto com object.instance_variables

Recursively converter seus objetos em Hash usando 'Hashable' gem ( https://rubygems.org/gems/hashable ) Exemplo

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

Pode querer tentar instance_values. Isso funcionou para mim.

Produz uma cópia superficial como um objeto de hash apenas dos atributos do modelo

my_hash_gift = gift.attributes.dup

Verifique o tipo do objeto resultante

my_hash_gift.class
=> Hash

Se você precisar que objetos aninhados também sejam convertidos.

# @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

Para fazer isso sem o Rails, uma maneira limpa é armazenar atributos em uma constante.

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

E então, para converter uma instância de Giftpara a Hash, você pode:

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

Essa é uma boa maneira de fazer isso, pois incluirá apenas o que você define attr_accessore não todas as variáveis ​​de instância.

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}

Comecei a usar estruturas para facilitar as conversões de hash. Em vez de usar uma estrutura simples, crio minha própria classe derivada de um hash, isso permite que você crie suas próprias funções e documenta as propriedades de uma classe.

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}