Ruby convertir un objet en hachage

Disons que j'ai un Giftobjet avec @name = "book"& @price = 15.95. Quelle est la meilleure façon de convertir cela en Hash {name: "book", price: 15.95}dans Ruby, pas en Rails (bien que n'hésitez pas à donner la réponse Rails aussi)?

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}

Dites simplement (objet actuel) .attributes

.attributesrenvoie a hashde any object. Et c'est aussi beaucoup plus propre.

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

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

Vous pouvez utiliser la as_jsonméthode. Cela convertira votre objet en hachage.

Mais, ce hachage viendra en tant que valeur du nom de cet objet en tant que clé. Dans ton cas,

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

Si vous avez besoin d'un hachage stocké dans l'objet, utilisez as_json(root: false). Je pense que la racine par défaut sera fausse. Pour plus d'informations, reportez-vous au guide officiel de rubis

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

Pour les objets d'enregistrement actifs

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

et puis juste appeler

gift.to_hash()
purch.to_hash() 

Si vous n'êtes pas dans un environnement Rails (c'est-à-dire que vous n'avez pas ActiveRecord disponible), cela peut être utile:

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

Vous pouvez écrire une solution très élégante en utilisant 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

Vous devez remplacer la inspectméthode de votre objet pour renvoyer le hachage souhaité, ou simplement implémenter une méthode similaire sans remplacer le comportement par défaut de l'objet.

Si vous voulez être plus sophistiqué, vous pouvez parcourir les variables d'instance d'un objet avec object.instance_variables

Convertissez récursivement vos objets en hachage en utilisant un gem 'hashable' ( 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}}]}

Je veux peut-être essayer instance_values. Cela a fonctionné pour moi.

Produit une copie superficielle en tant qu'objet de hachage des seuls attributs du modèle

my_hash_gift = gift.attributes.dup

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

my_hash_gift.class
=> Hash

Si vous avez également besoin de convertir des objets imbriqués.

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

Pour ce faire sans Rails, une méthode propre consiste à stocker les attributs sur une constante.

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

Et puis, pour convertir une instance de Giften a 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 un bon moyen de le faire car il n'inclura que ce que vous définissez attr_accessor, et non toutes les variables 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}

J'ai commencé à utiliser des structures pour faciliter les conversions de hachage. Au lieu d'utiliser une structure nue, je crée ma propre classe dérivée d'un hachage, cela vous permet de créer vos propres fonctions et de documenter les propriétés d'une 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}