माई रूबी एप्लिकेशन में क्या हो रहा है?

यदि आप सोच रहे हैं कि आपके रूबी एप्लिकेशन के साथ क्या हो रहा है…

कोई फैंसी GUI टूल नहीं हैं …

लेकिन हमारे पास ऑब्जेक्टस्पेस मॉड्यूल है!

ऑब्जेक्टस्पेस आपको आपके आवेदन की वर्तमान स्थिति के बारे में जानकारी देता है।

आइए जानें कि यह कैसे काम करता है।

ऑब्जेक्ट गिनना

ObjectSpace का उपयोग करना आप जान सकते हैं कि आपके कार्यक्रम में वर्तमान में कौन सी वस्तुएं 'जीवित' हैं।

किसी वस्तु के जीवित रहने का क्या अर्थ है?

एक वस्तु तब तक जीवित रहती है जब तक उसके पास कोई संदर्भ इंगित करता है। संदर्भ वस्तु तक पहुँचने का एक तरीका है, जैसे चर या स्थिरांक।

यदि किसी वस्तु तक नहीं पहुंचा जा सकता है तो इसका मतलब है कि इसे स्मृति से हटाया जाना सुरक्षित है।

उदाहरण :

# The variable 'name' holds a reference to the string 'Dave'.
name = 'Dave'

# The 'name' variable now points to 'John'.
# 'Dave' no longer has a reference pointing to it.
name = 'John'

आइए अब ObjectSpace . का एक उदाहरण देखें कार्रवाई में:

require 'objspace'

# This is valid Ruby syntax, but doesn't work on irb/pry
ObjectSpace
  .each_object
  .inject(Hash.new 0) { |h,o| h[o.class] += 1; h }
  .sort_by { |k,v| -v }
  .take(10)
  .each { |klass, count| puts "#{count.to_s.ljust(10)} #{klass}" }


# Copy & paste version (use this for irb/pry)
ObjectSpace.each_object.inject(Hash.new 0) { |h,o| h[o.class] += 1; h }.sort_by { |k,v| -v }.take(10).each { |klass, count| puts "#{count.to_s.ljust(10)} #{klass}" }

यह आपकी शीर्ष -10 कक्षाओं के लिए वस्तु गणना के साथ एक तालिका प्रिंट करेगा।

Count      Class
-------------------------
5436       String
315        Class
251        Array
101        Encoding
69         Regexp
45         Hash
26         Module
25         Gem::Version
22         Gem::StubSpecification::StubLine
22         Gem::StubSpecification

यदि आपको स्मृति रिसाव का संदेह है तो आप हर घंटे इस डेटा को लॉग कर सकते हैं और पता लगा सकते हैं कि क्या कोई वस्तु गणना है जो हर समय बढ़ती रहती है लेकिन कभी कम नहीं होती है।

वस्तुओं के साथ मज़ा

ObjectSpace का उपयोग करते समय आपको वास्तविक वस्तुओं तक पहुंच प्राप्त होती है, न कि केवल उनके बारे में जानकारी, इसलिए आप कुछ मजेदार चीजें कर सकते हैं जैसे सभी स्ट्रिंग्स के मूल्य को प्रिंट करना या अपनी सभी File के पथ को प्रिंट करना वस्तुओं।

उदाहरण :

ObjectSpace
  .each_object(String)
  .sort_by { |s| s.size }
  .each { |s| p s }

यह आकार के अनुसार क्रमबद्ध सभी इन-मेमोरी स्ट्रिंग्स को प्रिंट करेगा। आप देखेंगे कि कई तार हैं जो आपने स्वयं नहीं बनाए हैं, वे रूबी दुभाषिया द्वारा बनाए गए हैं।

व्यावहारिक उपयोग?

खैर, यह ज्यादातर आपके ऐप के बारे में डिबगिंग और आंकड़े इकट्ठा करने के लिए है 🙂

ऑब्जेक्ट मेमोरी साइज

एक और चीज जो आप कर सकते हैं वह है ObjectSpace.memsize_of . का उपयोग करना किसी विशेष वस्तु की स्मृति आकार खोजने के लिए।

उदाहरण :

o = "a" * 100
ObjectSpace.memsize_of(o)

दस्तावेज़ीकरण से यह चेतावनी ध्यान में रखने वाली एक बात है:

“ध्यान दें कि वापसी का आकार अधूरा है। आपको इस जानकारी से केवल एक संकेत के रूप में निपटने की आवश्यकता है।"

यदि आप विभिन्न प्रकार की वस्तुओं के साथ इस विधि को आजमाते हैं आपको कुछ दिलचस्प चीजें मिलेंगी , जैसे Fixnum s हमेशा 0 लौट रहा है।

ObjectSpace.memsize_of(42)
# 0

इसका कारण यह है कि रूबी आंतरिक रूप से Fixnum नहीं बनाती है ऑब्जेक्ट्स, आप इसके बारे में रूबी में संख्याओं के बारे में मेरे द्वारा लिखी गई पोस्ट में अधिक जान सकते हैं।

एक और दिलचस्प स्ट्रिंग हैं:

ObjectSpace.memsize_of("A" * 22)
# 40

ObjectSpace.memsize_of("A" * 23)
# 40

ObjectSpace.memsize_of("A" * 24)
# 65

मैं "A" * size . का उपयोग करता हूं इसे टाइप किए बिना लंबी स्ट्रिंग बनाने के तरीके के रूप में 🙂

रुकना! अभी क्या हुआ?

खैर, यह पता चला है कि रूबी में 24 वर्णों से छोटे स्ट्रिंग्स के लिए एक अंतर्निहित अनुकूलन है, इसलिए उसके बाद स्मृति उपयोग में उछाल आया है। आप इसे इस पोस्ट में पैट शौघनेस से और अधिक विस्तार से देख सकते हैं।

उपनाम तरीके कैसे खोजें

क्या यह अच्छा नहीं होगा यदि रूबी में सभी उपनामित विधियों की 'मास्टर' सूची हो?

इच्छा दी गई!

इसे देखें :

class Module
  def aliased_methods
    instance_methods(false)
      .group_by { |m| instance_method(m) }
      .map(&:last)
      .keep_if { |symbols| symbols.length > 1 }
  end
end

मुझे यह कोड स्टैक ओवरफ्लो उत्तर से मिला है। यह एक aliased_methods . को परिभाषित करता है Module . पर विधि वर्ग, जो instance_methods . का उपयोग करता है एक वर्ग पर परिभाषित सभी उदाहरण विधियों की सूची प्राप्त करने की विधि।

मुझे पता है कि यह थोड़ा भ्रमित करने वाला लग सकता है, लेकिन यह आपके लिए मेटाप्रोग्रामिंग है!

यहां शेष कोड है, जो सभी वर्ग नामों की एक सरणी बनाता है जिसमें कम से कम एक 'जीवित' वस्तु होती है, फिर वह aliased_methods को कॉल करता है हर वर्ग पर और आउटपुट प्रिंट करता है।

objects = ObjectSpace.each_object.map(&:class).uniq

objects.each do |klass|
   methods = "n#{klass}n#{'-'*20}n"

   klass.send(:aliased_methods).each do |m1, m2|
     methods << "#{m1.to_s.ljust(15)} #{m2}n"
   end

   puts methods
end

आउटपुट ऐसा दिखता है :

Array
--------------------
inspect         to_s
[]              slice
length          size
find_index      index
collect         map
collect!        map!

निष्कर्ष

मुझे आशा है कि आपको ObjectSpace . के साथ बढ़िया चीज़ें सीखने में मज़ा आया होगा , अब इसे आज़माएं और अगर आपको कुछ दिलचस्प लगे तो मुझे बताएं!

इस पोस्ट को अपने सभी प्रोग्रामर दोस्तों के साथ शेयर करना न भूलें, इससे उन्हें कुछ नया सीखने में मदद मिलेगी और इससे मुझे अधिक पाठक प्राप्त करने में मदद मिलेगी 🙂