Ruby konvertiert Objekt in Hash

Angenommen, ich habe ein GiftObjekt mit @name = "book"& @price = 15.95. Was ist der beste Weg, um dies {name: "book", price: 15.95}in Ruby in Hash umzuwandeln , nicht in Rails (obwohl Sie auch gerne die Antwort von Rails geben können)?

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}

Alternativ mit 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}

Sagen Sie einfach (aktuelles Objekt) .attributes

.attributesgibt a hashvon any zurück object. Und es ist auch viel sauberer.

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

Sie können as_jsonMethode verwenden. Es wird Ihr Objekt in Hash konvertieren.

Dieser Hash wird jedoch als Wert für den Namen dieses Objekts als Schlüssel verwendet. In deinem Fall,

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

Wenn Sie einen Hash benötigen, der im Objekt gespeichert ist, verwenden Sie as_json(root: false). Ich denke, standardmäßig wird root falsch sein. Weitere Informationen finden Sie im offiziellen Ruby-Leitfaden

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

Für aktive Datensatzobjekte

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

und dann einfach anrufen

gift.to_hash()
purch.to_hash() 

Wenn Sie sich nicht in einer Rails-Umgebung befinden (dh ActiveRecord nicht verfügbar haben), kann dies hilfreich sein:

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

Sie können eine sehr elegante Lösung mit einem funktionalen Stil schreiben.

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

Sie sollten die inspectMethode Ihres Objekts überschreiben , um den gewünschten Hash zurückzugeben, oder einfach eine ähnliche Methode implementieren, ohne das Standardobjektverhalten zu überschreiben.

Wenn Sie schicker werden möchten, können Sie die Instanzvariablen eines Objekts mit object.instance_variables durchlaufen

Recursively Ihre Objekte Hash konvertieren mit 'hashable' gem ( https://rubygems.org/gems/hashable ) Beispiel

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

Vielleicht möchten Sie es versuchen instance_values. Das hat bei mir funktioniert.

Erzeugt eine flache Kopie als Hash-Objekt nur der Modellattribute

my_hash_gift = gift.attributes.dup

Überprüfen Sie den Typ des resultierenden Objekts

my_hash_gift.class
=> Hash

Wenn Sie auch verschachtelte Objekte konvertieren möchten.

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

Um dies ohne Rails zu tun, besteht eine saubere Möglichkeit darin, Attribute auf einer Konstanten zu speichern.

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

Um eine Instanz von Giftin eine zu konvertieren Hash, können Sie:

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

Dies ist ein guter Weg, da dies nur das enthält, was Sie definieren attr_accessor, und nicht jede Instanzvariable.

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}

Ich habe angefangen, Strukturen zu verwenden, um Hash-Konvertierungen zu vereinfachen. Anstatt eine bloße Struktur zu verwenden, erstelle ich meine eigene Klasse, die aus einem Hash abgeleitet ist. Auf diese Weise können Sie Ihre eigenen Funktionen erstellen und die Eigenschaften einer Klasse dokumentieren.

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}