Shulou(Shulou.com)05/31 Report--

This article mainly introduces "Ruby serialization and persistent storage how to achieve", in daily operation, I believe many people in Ruby serialization and persistent storage how to achieve the problem there are doubts, Xiaobian consulted all kinds of information, sorted out simple and easy to use operation methods, I hope to answer "Ruby serialization and persistent storage how to achieve" doubts helpful! Next, please follow the small series to learn together!

Ruby Marshal serialization

Marshal is Ruby's core library, which can serialize some objects into files in binary mode, and then load them from files to reconstruct objects when necessary, i.e. deserialize.

Marshal has no problem serializing and preserving underlying data such as numeric values, strings, arrays, and booleans.

However, not all types of data can be serialized. Marshal performs some operations as it loads and reconstructs objects from serialized files, but some of the content of the restore process may be lost. It cannot serialize I0 stream objects and code class objects: Proc objects, singleton objects, anonymous classes, and modules, which is its limitation.

The serialization and deserialization process is simple:

#a nested array arr = [ %w(Perl Python PHP), %w(C C++ Java Golang), %w(Shell Powershell Cmdline) ]#serialize arr object to file File.open ('/tmp/data.dat',"w") do| file| Marshal.dump(arr, file)end#deserialize File.open ('/tmp/data.dat') do| file| data = Marshal.load(file)endp data

Marshal.dump() can also specify the maximum number of nested object hierarchies allowed to be serialized, i.e., depth, with a third parameter, beyond which an error will be reported. Its default value is-1, which means that depth is not checked, i.e. dump all levels. For example:

arr = [ %w(Perl Python PHP), [ %w(C C++), %(Java Golang) ], #=> Layer 3% w(Shell Powershell Cmdline) ]#Save arr object serialization to file File.open ('/tmp/data.dat',"w") do| file| Marshal.dump(arr, file, 4) #=> Less than 4 will report an error end

If you want to specify what to serialize in an object, or what type to serialize, you can write the marshal_dump and marshal_load methods in your class. For example, dump only a portion of the data and save it as an array:

class Klass def initialize name, age, height @name = name @age = age @height = height end def marshal_dump [@name, @age] end #deserialize, arr is the array when serialized #eventually it returns an instance object of Klass def marshal_load arr @name, @age = arr end #Serializes an object of Klass, but only contains the name and age attributes obj = Klass.new ("junmajinlong", 23, 170)File.open ('/tmp/me.dat','w') do| file| Marshal.dump(obj, file)end#deserialize, get an instance object of Klass, and set the name and age properties obj1 = File.open ("/tmp/me.dat") do| file| Marshal.load fileendp obj1#=> #

Obviously, there is a height attribute missing from the deserialization above. In order to complete the object, the deserialization needs to construct a new object reasonably according to the result of deserialization. For example, use instance_eval() to build a new object:

def marshal_load arr self.instance_eval do initialize(*arr, 170) endRuby Pstore Store

Pstore(persistence store) is Ruby's standard library for persistent storage, which stores data in a key-value (binary) file based on the Hash data type, where value is the data you want to store and key is a name for the data.

In Pstore, keys are called roots, and each key is a root.

Pstore is transaction-based, so the process of adding, deleting and modifying data many times is atomic, and can be committed and aborted uniformly. Both commit() and abort() immediately terminate the transaction, so the code that follows them is not executed, and if commit() or abort() is not specified, it is automatically saved when exiting the transaction.

Because pstore loads part of the file into memory every time it reads (until it finds the corresponding key), reading efficiency is not high. Furthermore, each write requires copying most of the file data, so it is less efficient. Therefore, Pstore is only suitable for data storage scenarios with small amounts of data and small amounts of reads and writes.

For example, persistence saves to files:

require 'pstore's = PStore.new ('/tmp/pstore.dat')s.transaction do s["p1"] = {name: "junmajinlong", age: 23, height: 170 } s["p2"] = {name: "junma", age: 22, height: 180} s.commit s["p3"] = {name: "jinlong", age: 24}ends.transaction do #overwrite p2 s["p2"] = {name: "jinlong", age: 24, height: 170 } end #=> Auto commit

Read data from pstore file:

require 'pstore's = PStore.new("/tmp/pstore.dat")p2 = s.transaction do s["p2"]endp p2puts p2.name

transaction(read_only=false) You can also specify parameters to set whether the transaction is read-only. If read-only is set, any modification to the pstore within the transaction will throw an error.

Pstore has some other auxiliary methods:

[KEY] : Gets the value of the element, returns nildelete() if the element does not exist: deletes the element, specifies the default value if the element does not exist Parameter fetch() : Get element, if element does not exist, default error, can specify default return value path() : Return the path to the pstore file root? () Check if there are roots() : Return all keys to this, and the study of "How to implement Ruby serialization and persistent storage" is over. I hope to solve everyone's doubts. Theory and practice can better match to help everyone learn, go and try it! If you want to continue learning more relevant knowledge, please continue to pay attention to the website, Xiaobian will continue to strive to bring more practical articles for everyone!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.