Ruby on Rails 5.2 - ActiveModel::Serialization

मॉड्यूल एक्टिवमॉडल :: सीरियललाइज़ेशन




ruby

मॉड्यूल एक्टिवमॉडल :: सीरियललाइज़ेशन

सक्रिय मॉडल सीरियल

अपनी वस्तुओं के लिए #serializable_hash को मूल क्रमबद्धता प्रदान करता है।

एक न्यूनतम कार्यान्वयन हो सकता है:

class Person
  include ActiveModel::Serialization

  attr_accessor :name

  def attributes
    {'name' => nil}
  end
end

जो आपको प्रदान करेगा:

person = Person.new
person.serializable_hash   # => {"name"=>nil}
person.name = "Bob"
person.serializable_hash   # => {"name"=>"Bob"}

एक attributes हैश को परिभाषित किया जाना चाहिए और इसमें किसी भी विशेषता को शामिल किया जाना चाहिए जिसमें आपको क्रमबद्ध होना चाहिए। गुण तार होने चाहिए, प्रतीक नहीं। जब कहा जाता है, serializable हैश ऐसे तरीकों का उपयोग करेगा जो विशेषताओं हैश की कुंजी के नाम से मेल खाते हैं। इस व्यवहार को ओवरराइड करने के लिए, निजी विधि read_attribute_for_serialization पर एक नज़र read_attribute_for_serialization

ActiveModel::Serializers::JSON मॉड्यूल में स्वचालित रूप से ActiveModel::Serialization मॉड्यूल शामिल है, इसलिए ActiveModel::Serialization को स्पष्ट रूप से शामिल करने की आवश्यकता नहीं है।

JSON सहित एक न्यूनतम कार्यान्वयन होगा:

class Person
  include ActiveModel::Serializers::JSON

  attr_accessor :name

  def attributes
    {'name' => nil}
  end
end

जो आपको प्रदान करेगा:

person = Person.new
person.serializable_hash   # => {"name"=>nil}
person.as_json             # => {"name"=>nil}
person.to_json             # => "{\"name\":null}"

person.name = "Bob"
person.serializable_hash   # => {"name"=>"Bob"}
person.as_json             # => {"name"=>"Bob"}
person.to_json             # => "{\"name\":\"Bob\"}"

वैध विकल्प हैं :only :except , :methods और :include । निम्नलिखित सभी मान्य उदाहरण हैं:

person.serializable_hash(only: 'name')
person.serializable_hash(include: :address)
person.serializable_hash(include: { address: { only: 'city' }})

सार्वजनिक प्रवृत्ति के तरीके

serializable_hash (विकल्प = शून्य) स्रोत दिखाएं
# File activemodel/lib/active_model/serialization.rb, line 126
def serializable_hash(options = nil)
  options ||= {}

  attribute_names = attributes.keys
  if only = options[:only]
    attribute_names &= Array(only).map(&:to_s)
  elsif except = options[:except]
    attribute_names -= Array(except).map(&:to_s)
  end

  hash = {}
  attribute_names.each { |n| hash[n] = read_attribute_for_serialization(n) }

  Array(options[:methods]).each { |m| hash[m.to_s] = send(m) }

  serializable_add_includes(options) do |association, records, opts|
    hash[association.to_s] = if records.respond_to?(:to_ary)
      records.to_ary.map { |a| a.serializable_hash(opts) }
    else
      records.serializable_hash(opts)
    end
  end

  hash
end

अपनी वस्तु का क्रमबद्ध हैश लौटाता है।

class Person
  include ActiveModel::Serialization

  attr_accessor :name, :age

  def attributes
    {'name' => nil, 'age' => nil}
  end

  def capitalized_name
    name.capitalize
  end
end

person = Person.new
person.name = 'bob'
person.age  = 22
person.serializable_hash                # => {"name"=>"bob", "age"=>22}
person.serializable_hash(only: :name)   # => {"name"=>"bob"}
person.serializable_hash(except: :name) # => {"age"=>22}
person.serializable_hash(methods: :capitalized_name)
# => {"name"=>"bob", "age"=>22, "capitalized_name"=>"Bob"}

इसके साथ उदाहरण :include विकल्प :include

class User
  include ActiveModel::Serializers::JSON
  attr_accessor :name, :notes # Emulate has_many :notes
  def attributes
    {'name' => nil}
  end
end

class Note
  include ActiveModel::Serializers::JSON
  attr_accessor :title, :text
  def attributes
    {'title' => nil, 'text' => nil}
  end
end

note = Note.new
note.title = 'Battle of Austerlitz'
note.text = 'Some text here'

user = User.new
user.name = 'Napoleon'
user.notes = [note]

user.serializable_hash
# => {"name" => "Napoleon"}
user.serializable_hash(include: { notes: { only: 'title' }})
# => {"name" => "Napoleon", "notes" => [{"title"=>"Battle of Austerlitz"}]}