Ruby Object'i Hash'e çevirir

Diyelim ki & Giftile bir nesnem var . Bunu Ruby'de Hash'e dönüştürmenin en iyi yolu nedir, Rails'e değil (Rails'in cevabını da vermekten çekinmeyin)?@name = "book"@price = 15.95{name: "book", price: 15.95}

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}

Alternatif olarak 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}

Sadece söyle (mevcut nesne) .attributes

.attributeshashherhangi birinden a döndürür object. Ve çok daha temiz.

Uygulamak #to_hashmı?

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}

Kullanabilirsiniz as_jsonYöntemi . Nesnenizi hash'e dönüştürecektir.

Ancak bu hash, anahtar olarak o nesnenin adına bir değer olarak gelecektir. Senin durumunda,

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

Nesne kullanımında depolanan bir hash'e ihtiyacınız varsa as_json(root: false). Varsayılan olarak kökün yanlış olacağını düşünüyorum. Daha fazla bilgi için resmi yakut kılavuzuna bakın

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

Aktif Kayıt Nesneleri için

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

ve sonra sadece ara

gift.to_hash()
purch.to_hash() 

Bir Rails ortamında değilseniz (yani ActiveRecord yoksa), bu yardımcı olabilir:

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

Fonksiyonel bir tarz kullanarak çok şık bir çözüm yazabilirsiniz.

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

Geçersiz kılmalısınız inspect istenen karma dönmek için nesnenin yöntemini, ya da sadece varsayılan nesne davranışını geçersiz kılma olmadan benzer bir yöntem uygulamak.

Daha meraklısı olmak istiyorsanız, object.instance_variables ile bir nesnenin örnek değişkenlerini yineleyebilirsiniz.

Yinelemeli kullanarak karma için nesneleri dönüştürmek 'hashable' taş ( https://rubygems.org/gems/hashable ) Örnek

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

Denemek isteyebilirsin instance_values. Bu benim için çalıştı.

Sadece model özniteliklerinin karma nesnesi olarak sığ bir kopya üretir

my_hash_gift = gift.attributes.dup

Ortaya çıkan nesnenin türünü kontrol edin

my_hash_gift.class
=> Hash

İç içe yerleştirilmiş nesnelerin de dönüştürülmesine ihtiyacınız varsa.

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

Bunu Rails olmadan yapmanın temiz bir yolu, nitelikleri bir sabit üzerinde depolamaktır.

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

Ve sonra, bir örneğini dönüştürmek için Giftbir etmek Hash, şunları yapabilirsiniz:

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

Bu, bunu yapmanın iyi bir yoludur çünkü attr_accessorher örnek değişkeni değil, yalnızca tanımladığınız şeyi içerecektir .

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}

Dönüşümleri kolay hale getirmek için yapıları kullanmaya başladım. Çıplak bir yapı kullanmak yerine, bir hash'den türetilen kendi sınıfımı yaratırım bu, kendi işlevlerinizi oluşturmanıza olanak tanır ve bir sınıfın özelliklerini belgeler.

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}