Ruby convertit l'Objet de Hachage

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}

Alternativement avec 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}

Mettre en œuvre #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

Vous pouvez utiliser as_json méthode. Il va convertir votre objet dans hachage.

Mais, que de hachage viendra comme une valeur pour le nom de l'objet en tant que clé. Dans votre cas,

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

Si vous avez besoin d'un hachage qui est stockée dans l'objet de l'utilisation as_json(root: false). Je pense que par défaut, la racine sera faux. Pour plus d'informations, reportez-vous officiel ruby guide

http://api.rubyonrails.org/classes/ActiveModel/Serializers/JSON.html#method-i-as_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

Vous pouvez écrire une solution élégante à l'aide d'un style fonctionnel.

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

De manière récursive convertir vos objets de hachage à l'aide de 'hashable" gem (https://rubygems.org/gems/hashable)
Exemple

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

Produit d'une copie d'un algorithme de hachage de l'objet de tout les attributs de modèle

my_hash_gift = gift.attributes.dup

Vérifier le type de l'objet résultant

my_hash_gift.class
=> Hash

Si vous avez besoin d'objets imbriqués pour être converties en tant que bien.

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

Pour ce faire, sans Rails, un moyen propre est de stocker les attributs sur une constante.

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

Et puis, pour convertir une instance de Gift à un Hash, vous pouvez:

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

C'est une bonne façon de le faire, car il ne comprendra ce que vous définissez sur attr_accessor, et non pas chaque variable d'instance.

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}