Ruby konwertuje Object na Hash

Powiedzmy, że mam Giftobiekt z @name = "book"& @price = 15.95. Jaki jest najlepszy sposób na przekonwertowanie tego na Hash {name: "book", price: 15.95}w Ruby, a nie Railsy (chociaż możesz też udzielić odpowiedzi Railsom)?

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}

Alternatywnie z 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}

Po prostu powiedz (bieżący obiekt) .attributes

.attributeszwraca hashz any object. Jest też dużo czystszy.

Wdrożyć #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}

Możesz użyć as_jsonmetody. Przekształci twój obiekt w hash.

Ale ten skrót będzie wartością dla nazwy tego obiektu jako klucza. W Twoim przypadku,

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

Jeśli potrzebujesz skrótu przechowywanego w obiekcie, użyj as_json(root: false). Myślę, że domyślnie root będzie fałszywy. Aby uzyskać więcej informacji, zapoznaj się z oficjalnym przewodnikiem po Rubim

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

Dla obiektów Active Record

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

a potem po prostu zadzwoń

gift.to_hash()
purch.to_hash() 

Jeśli nie jesteś w środowisku Railsów (tj. Nie masz dostępnego ActiveRecord), może to być pomocne:

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

Możesz napisać bardzo eleganckie rozwiązanie używając funkcjonalnego stylu.

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

Powinieneś zastąpić inspectmetodę obiektu, aby zwrócić żądany skrót, lub po prostu zaimplementować podobną metodę bez zastępowania domyślnego zachowania obiektu.

Jeśli chcesz być bardziej wyrafinowany, możesz iterować zmienne instancji obiektu za pomocą object.instance_variables

Rekurencyjnie konwertuj swoje obiekty na hash za pomocą klejnotu „hashable” ( https://rubygems.org/gems/hashable ) Przykład

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

Może zechcesz spróbować instance_values. To zadziałało dla mnie.

Tworzy płytką kopię jako obiekt skrótu tylko atrybutów modelu

my_hash_gift = gift.attributes.dup

Sprawdź typ wynikowego obiektu

my_hash_gift.class
=> Hash

Jeśli potrzebujesz również konwersji zagnieżdżonych obiektów.

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

Aby to zrobić bez Railsów, czystym sposobem jest przechowywanie atrybutów w stałej.

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

Następnie, aby przekonwertować wystąpienie Giftna a Hash, możesz:

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

Jest to dobry sposób na zrobienie tego, ponieważ będzie obejmował tylko to, co zdefiniujesz attr_accessor, a nie każdą zmienną instancji.

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}

Zacząłem używać struktur, aby ułatwić konwersje haszujące. Zamiast używać czystej struktury, tworzę własną klasę wywodzącą się z skrótu, co pozwala na tworzenie własnych funkcji i dokumentuje właściwości klasy.

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}