Ruby converte Object in Hash

Diciamo che ho un Giftoggetto con @name = "book"& @price = 15.95. Qual è il modo migliore per convertirlo in Hash {name: "book", price: 15.95}in Ruby, non in Rails (anche se sentiti libero di dare anche la risposta a 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}

In alternativa con 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}

Basta dire (oggetto corrente) .attributes

.attributesrestituisce uno hashdi qualsiasi object. Ed è anche molto più pulito.

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

Puoi usare il as_jsonmetodo. Converte il tuo oggetto in hash.

Ma quell'hash arriverà come valore al nome di quell'oggetto come chiave. Nel tuo caso,

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

Se hai bisogno di un hash memorizzato nell'oggetto usa as_json(root: false). Penso che per impostazione predefinita root sia falso. Per maggiori informazioni consultare la guida ufficiale ruby

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

Per oggetti record attivi

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 poi chiama

gift.to_hash()
purch.to_hash() 

Se non ti trovi in ​​un ambiente Rails (ad es. Non hai ActiveRecord disponibile), questo può essere 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

Puoi scrivere una soluzione molto elegante usando uno stile funzionale.

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

Dovresti sovrascrivere il inspectmetodo dell'oggetto per restituire l'hash desiderato o semplicemente implementare un metodo simile senza sovrascrivere il comportamento dell'oggetto predefinito.

Se vuoi diventare più elaborato, puoi scorrere le variabili di istanza di un oggetto con object.instance_variables

Converti ricorsivamente i tuoi oggetti in hash usando la gemma "hashable" ( https://rubygems.org/gems/hashable ) Esempio

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

Potrebbe voler provare instance_values. Questo ha funzionato per me.

Produce una copia superficiale come oggetto hash solo degli attributi del modello

my_hash_gift = gift.attributes.dup

Controlla il tipo di oggetto risultante

my_hash_gift.class
=> Hash

Se hai bisogno di convertire anche oggetti nidificati.

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

Per fare questo senza Rails, un modo pulito è quello di memorizzare gli attributi su una costante.

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

Quindi, per convertire un'istanza di Giftin a Hash, puoi:

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

Questo è un buon modo per farlo perché includerà solo ciò che si definisce attr_accessore non tutte le variabili di istanza.

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}

Ho iniziato a utilizzare le strutture per semplificare le conversioni di hash. Invece di usare una struttura nuda, creo la mia classe derivante da un hash che ti permette di creare le tue funzioni e documenta le proprietà di una 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}