रूबी 2.1 विस्तार से (भाग 1)

रूबी 2.1, रूबी (लेखन के समय) का नवीनतम महत्वपूर्ण संस्करण, क्रिसमस 2013 में जारी किया गया था, 2.0.0 के जारी होने के ठीक 10 महीने बाद। वह कई परिवर्तनों और सुधारों के साथ बाहर आई, और इस पोस्ट में इन नवाचारों के बारे में विस्तार से वर्णन किया गया है।

नई संस्करण नीति

संस्करण 2.1 के साथ, रूबी सिमेंटिक संस्करण के आधार पर एक नई संस्करण योजना पर जा रहा है।



संस्करण MAJOR.MINOR.TEENY योजना के अनुसार जारी किए गए हैं, अर्थात संस्करण 2.1.0 में: 2 - प्रमुख संस्करण, 1 - मामूली, मामूली संस्करण - 0. मामूली संस्करण संख्या मामूली बग और सुरक्षा कमजोरियों के लिए पैच से ली गई है। मामूली संस्करण संख्या का उपयोग नई सुविधाओं के लिए किया जाएगा, अधिकांश भाग पिछड़े संगत के लिए, और प्रमुख एक - असंगत परिवर्तनों के लिए जो मामूली संस्करण के तहत जारी नहीं किया जा सकता है।



इसका मतलब है कि उदाहरण के लिए, 1.9.3 और 1.9.3-p545 के बजाय, हमें फॉर्म 2.1 और 2.1.1 की रिलीज मिलती है।



यह हर 12 महीने में छोटे संस्करणों को जारी करने की योजना है, अर्थात्। हम क्रिसमस 2014 तक रूबी 2.2 की उम्मीद कर सकते हैं।

आवश्यक नामांकित तर्क

रूबी 2.0.0 में पेश किए गए नामित तर्कों में एक मामूली सुधार जोड़ा गया है। अब, आप किसी विधि को परिभाषित करते समय नामित तर्कों के लिए डिफ़ॉल्ट मान को छोड़ सकते हैं, और यदि विधि को कॉल करते समय उन्हें निर्दिष्ट नहीं किया जाता है, तो एक त्रुटि उठाई जाएगी।

# length is required def pad(num, length:, char: "0") num.to_s.rjust(length, char) end pad(42, length: 6) #=> "000042" pad(42) #=> #<ArgumentError: missing keyword: length>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

जैसा कि आप ऊपर के उदाहरण से देख सकते हैं, कुछ स्थितियों में, अस्पष्टता को हल करने के लिए नामित तर्क आवश्यक हैं, लेकिन आप उनके लिए एक उपयुक्त डिफ़ॉल्ट मान नहीं पा सकते हैं। अब आपको चुनने की आवश्यकता नहीं है।

स्ट्रिंग # फ्रीज विधि अनुकूलन

क्योंकि रूबी में तार परस्पर हैं, प्रत्येक स्ट्रिंग शाब्दिक प्रत्येक निष्पादन में एक नई वस्तु है:

 def env "development" end # returns new String object on each call env.object_id #=> 70329318373020 env.object_id #=> 70329318372900
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह बहुत बेकार हो सकता है - पहले कई ऑब्जेक्ट बनाएं और फिर उन्हें कचरा कलेक्टर के साथ हटा दें। इससे बचने के लिए, आप सीधे #freeze विधि को कॉल कर सकते हैं, जिसका अर्थ है कि पंक्ति खोज "जमे हुए" पंक्तियों की तालिका के माध्यम से जाएगी, और हर बार उसी ऑब्जेक्ट का उपयोग किया जाएगा:

 def env "development".freeze end # returns the same String object on each call env.object_id #=> 70365553080120 env.object_id #=> 70365553080120
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

स्ट्रिंग कुंजी जो कि हैश कीज़ हैं उसी तरह से प्रोसेस किया जाएगा बिना #freeze के कॉल किए बिना।

 a = {"name" => "Arthur"} b = {"name" => "Ford"} # same String object used as key in both hashes a.keys.first.object_id #=> 70253124073040 b.keys.first.object_id #=> 70253124073040
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

विकास 2.1 के दौरान, यह सुविधा मूल रूप से सिंटैक्स में एक बदलाव था, जहां "स्ट्रिंग" एफ "फ्रोजन" स्ट्रिंग के लिए खड़ा था। हालांकि, इस तरह के बदलाव से कॉल करने का निर्णय लिया गया था # कॉलिंग विधि को कॉल करना, जो प्रत्यक्ष और पिछड़े संगतता को नहीं तोड़ता है, साथ ही कई लोग सिंटैक्स में अनावश्यक बदलाव पसंद नहीं करते हैं।

def एक प्रतीक वस्तु के रूप में विधि का नाम देता है

विधि घोषणा का परिणाम अब शून्य नहीं है, लेकिन विधि नाम के अनुरूप प्रतीक वस्तु है। इसका उपयोग करने का एक विहित उदाहरण केवल एक विधि को निजी घोषित करना है:

 class Client def initialize(host, port) # ... end private def do_request(method, path, body, **headers) # ... end def get(path, **headers) do_request(:get, path, nil, **headers) end end
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इसे डेकोरेटर को विधियों में जोड़ने के लिए भी इस्तेमाल किया जा सकता है, कॉलबैक के पहले / बाद में एक विधि को लपेटने के लिए मॉड्यूल # प्रीपेंड का उपयोग करने का एक उदाहरण है:

 module Around def around(method) prepend(Module.new do define_method(method) do |*args, &block| send(:"before_#{method}") if respond_to?(:"before_#{method}", true) result = super(*args, &block) send(:"after_#{method}") if respond_to?(:"after_#{method}", true) result end end) method end end class Example extend Around around def call puts "call" end def before_call puts "before" end def after_call puts "after" end end Example.new.call
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

लाएगा

 before call after
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

डिफाइन_मिथोड और डिफाइन_सिंगटन_मेथोड तरीके भी बदल दिए गए हैं और अब अपने खरीद तर्कों के बजाय प्रतीक वस्तुओं को वापस करते हैं।

तर्कसंगत और जटिल संख्याओं के लिए साहित्य

रूबी के पास कक्षाओं के लिए शाब्दिक हैं इंटेगर (1) और फ्लोट (1.0), अब कक्षाओं के लिए शाब्दिक, तर्कसंगत (1r) और कॉम्प्लेक्स (1i) को उनके लिए जोड़ा गया है।



वे रूबी में गणितीय कार्यों के लिए कास्ट मैकेनिज्म के साथ अच्छी तरह से काम करते हैं, इसलिए 1/3 को रूबी में 1 / 3r लिखा जा सकता है। 3i एक जटिल संख्या 0 + 3i का प्रतिनिधित्व करता है, जिसका अर्थ है कि मानक संख्याओं को मानक गणितीय अंकन में लिखा जा सकता है, रूबी में 2 + 3i एक जटिल संख्या 2 + 3i का प्रतिनिधित्व करता है!

एरे / एन्युमरेबल #to_h

रूबी 2.0.0 में #to_h पद्धति प्राप्त करने वाले कई वर्ग अब ऐरे वर्ग और किसी अन्य वर्ग के साथ समृद्ध होते हैं, जिसमें Enumerable शामिल है।

 [[:id, 42], [:name, "Arthur"]].to_h #=> {:id=>42, :name=>"Arthur"} require "set" Set[[:id, 42], [:name, "Arthur"]].to_h #=> {:id=>42, :name=>"Arthur"}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह उपयोगी हो सकता है जब हैश विधियों का उपयोग करें जो एक ऐरे को वापस करते हैं:

 headers = {"Content-Length" => 42, "Content-Type" => "text/html"} headers.map {|k, v| [k.downcase, v]}.to_h #=> {"content-length" => 42, "content-type" => "text/html"}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

साझा पद्धति कैशिंग

संस्करण 2.1 से पहले, रूबी ने एक वैश्विक विधि कैश का उपयोग किया था, जो सभी वर्गों के लिए एक नई विधि जोड़ते समय, एक मॉड्यूल को जोड़ने, एक ऑब्जेक्ट में एक मॉड्यूल सहित, आदि के लिए अमान्य हो गया था। आपके कोड में कहीं भी इसने कुछ वर्गों (जैसे ओपेनस्ट्रक्ट) और कुछ ट्रिक्स (जैसे अपवादों को टैग करना ) को प्रदर्शन के विचारों के कारण बेकार कर दिया।



अब यह कोई समस्या नहीं है, रूबी 2.1 एक वर्ग पदानुक्रम के आधार पर विधि कैशिंग का उपयोग करता है, केवल एक दिए गए वर्ग और उसके उपवर्गों के लिए कैश को अमान्य करता है।



RubyVM वर्ग में एक विधि जोड़ी गई है जो विधि कैश के लिए कुछ डीबगिंग जानकारी लौटाती है:

 class Foo end RubyVM.stat #=> {:global_method_state=>133, :global_constant_state=>820, :class_serial=>5689} # setting constant increments :global_constant_state Foo::Bar = "bar" RubyVM.stat(:global_constant_state) #=> 821 # defining instance method increments :class_serial class Foo def foo end end RubyVM.stat(:class_serial) #=> 5690 # defining global method increments :global_method_state def foo end RubyVM.stat(:global_method_state) #=> 134
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अपवाद

अपवाद ऑब्जेक्ट में अब एक #cause पद्धति है जो एक अपवाद देता है जो इसे फेंकता है। जब आप एक अपवाद को पकड़ते हैं और दूसरे को फेंकते हैं तो यह स्वचालित रूप से सेट हो जाता है।

 require "socket" module MyProject Error = Class.new(StandardError) NotFoundError = Class.new(Error) ConnectionError = Class.new(Error) def self.get(path) response = do_get(path) raise NotFoundError, "#{path} not found" if response.code == "404" response.body rescue Errno::ECONNREFUSED, SocketError => e raise ConnectionError end end begin MyProject.get("/example") rescue MyProject::Error => e e #=> #<MyProject::ConnectionError: MyProject::ConnectionError> e.cause #=> #<Errno::ECONNREFUSED: Connection refused - connect(2) for "example.com" port 80> end
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

फिलहाल, पहला अपवाद कहीं भी फेंका नहीं गया है और बचाव घटना के कारण पर ध्यान नहीं देता है, लेकिन #cause पद्धति की उपस्थिति डिबगिंग में काफी मदद कर सकती है।



अपवादों में #backtrace_locations विधि भी है, जो किसी कारण से 2.0.0 में उपलब्ध नहीं है । यह थ्रेड :: बैकट्रेस :: स्ट्रिंग्स के बजाय स्थान ऑब्जेक्ट्स देता है, जो बैकग्राउंड विवरणों तक आसान पहुंच प्रदान करता है।

पीढ़ीगत कचरा संग्रहकर्ता

रूबी 2.1 एक पीढ़ी-आधारित कचरा कलेक्टर का परिचय देता है जो सभी वस्तुओं को युवा और पुरानी पीढ़ियों में विभाजित करता है। सामान्य स्टार्टअप के दौरान, जीसी केवल युवा पीढ़ी की वस्तुओं को देखेगा, जबकि पुरानी पीढ़ी की वस्तुओं को बहुत कम बार देखा जाएगा। वस्तुओं को हटाना (स्वीप करना) 1.9.3 (आलसी स्वीप) के समान योजना के अनुसार किया जाता है। यदि युवा पीढ़ी जीसी शुरू होने पर "जीवित" होती है, तो वह पुरानी पीढ़ी में चली जाती है।



यदि आपके पास पुरानी पीढ़ी की वस्तुएं हैं जो युवा पीढ़ी की वस्तुओं को संदर्भित करती हैं, तो केवल युवा पीढ़ी को संसाधित करते समय, जीसी गलती से विचार कर सकता है कि इस ऑब्जेक्ट का कोई संदर्भ नहीं है और इसे हटा दें। इसे रोकने के लिए, अवरोधों को पेश किया गया था जो पुरानी पीढ़ी की वस्तुओं को एक विशेष याद सेट पर जोड़ते हैं जब वे युवा पीढ़ी की वस्तुओं (उदाहरण के लिए, old_array.push (young_string)) को संदर्भित करना शुरू करते हैं। युवा पीढ़ी को चिह्नित करते समय इस सेट को ध्यान में रखा जाता है।



अधिकांश पीढ़ीगत कचरा संग्राहकों को सभी वस्तुओं के लिए ऐसी बाधाओं की आवश्यकता होती है, लेकिन कई तृतीय-पक्ष रूबी सी-एक्सटेंशन के लिए यह संभव नहीं है। इसलिए, एक अस्थायी समाधान के रूप में, यह पेश किया गया था कि जिन वस्तुओं के लिए कोई बाधा नहीं बनाई गई थी (तथाकथित "छाया" वस्तुएं) कभी भी पुरानी पीढ़ी में नहीं आती हैं। यह समाधान एक पीढ़ीगत कचरा कलेक्टर की सभी क्षमताओं के पूर्ण उपयोग के लिए आदर्श नहीं है, लेकिन यह अधिकतम पिछड़े संगतता प्रदान करता है।



अब अंकन का चरण बहुत तेज है, लेकिन लिखने की बाधाओं की उपस्थिति का मतलब अतिरिक्त ओवरहेड है, इसलिए प्रदर्शन में अंतर सीधे इस बात पर निर्भर करता है कि आपका कोड क्या करता है।

कक्षा जी.सी.

GC.start पद्धति दो नए पैरामीटर प्राप्त कर सकती है, full_mark और तत्काल_sweep। डिफ़ॉल्ट रूप से दोनों सत्य हैं।

यदि full_mark को सही पर सेट किया गया है, तो अंकन चरण दोनों पीढ़ियों के लिए गुजरता है, यदि गलत है, तो केवल युवा के लिए। यदि तत्काल_स्वेप सही पर सेट किया गया है, तो रोकें दुनिया तुरंत पूरी तरह से हटा दी जाएगी; यदि गलत है, तो आलसी स्वीप केवल आवश्यक होने पर ही किया जाएगा और आवश्यक न्यूनतम वस्तुओं को हटा देगा।

 GC.start # trigger a full GC run GC.start(full_mark: false) # only collect young generation GC.start(immediate_sweep: false) # mark only GC.start(full_mark: false, immediate_sweep: false) # minor GC
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

डिबगिंग विकल्प GC.stress को अब पूर्णांक ध्वज के रूप में सेट किया जा सकता है जो यह निर्दिष्ट करता है कि कलेक्टर के किस हिस्से को मजबूत किया जाना चाहिए।

 GC.stress = true # full GC at every opportunity GC.stress = 1 # minor marking at every opportunity GC.stress = 2 # lazy sweep at every opportunity
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

GC.stat अब अधिक विवरण प्रदर्शित करता है, और एक इनपुट पैरामीटर भी प्राप्त कर सकता है और केवल मानों के पूरे हैश को प्रदर्शित करने के बजाय, इस कुंजी के लिए एक मान लौटा सकता है।

 GC.stat #=> {:count=>6, ... } GC.stat(:major_gc_count) #=> 2 GC.stat(:minor_gc_count) #=> 4
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

नवीनतम_gc_info पद्धति भी सामने आई है, जो पिछली बार कचरा इकट्ठा करने वाले के बारे में जानकारी देती है।

 GC.latest_gc_info #=> {:major_by=>:oldgen, :gc_by=>:newobj, :have_finalizer=>false, :immediate_sweep=>false}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

जीसी - पर्यावरण चर स्थापित करना

कई नए पर्यावरण चर पेश किए गए हैं जिन्हें रूबी कचरा संग्रहकर्ता के साथ काम करते समय माना जाता है।

RUBY_GC_HEAP_INIT_SLOTS

यह विकल्प पहले RUBY_HEAP_MIN_SLOTS के रूप में उपलब्ध था। यह स्लॉट्स का प्रारंभिक स्थान निर्धारित करता है और डिफ़ॉल्ट रूप से 10000 पर सेट होता है।

RUBY_GC_HEAP_FREE_SLOTS

यह विकल्प पूर्व में RUBY_FREE_MIN के रूप में भी उपलब्ध था। यह स्लॉट की न्यूनतम संख्या निर्धारित करता है जो जीसी शुरू करने के बाद उपलब्ध होनी चाहिए। यदि जीसी ने पर्याप्त स्लॉट जारी नहीं किए हैं, तो नए आवंटित किए जाएंगे। डिफ़ॉल्ट रूप से, 4096।

RUBY_GC_HEAP_GROWTH_FACTOR

गुणांक सेट करता है जिसके द्वारा आवंटित स्लॉट की संख्या में वृद्धि होगी। (अगले स्लॉट संख्या) = (वर्तमान स्लॉट संख्या) * (यह कारक)। डिफ़ॉल्ट 1.8 है।

RUBY_GC_HEAP_GROWTH_MAX_SLOTS

एक बार में आवंटित अधिकतम संख्या में स्लॉट। डिफ़ॉल्ट 0 है, जिसका अर्थ है कि अधिकतम सेट नहीं है।

RUBY_GC_MALLOC_LIMIT

यह विकल्प नया नहीं है, लेकिन एक उल्लेख के योग्य है। यह मेमोरी की मात्रा निर्धारित करता है जिसे कचरा संग्रह का सहारा लिए बिना आवंटित किया जा सकता है। डिफ़ॉल्ट 16 * 1024 * 1024 (16 एमबी) है।

RUBY_GC_MALLOC_LIMIT_GROWTH_FACTOR

वृद्धि कारक malloc_limit है, डिफ़ॉल्ट 1.4 है।

RUBY_GC_MALLOC_LIMIT_MAX

वह अधिकतम जो Malloc_limit तक पहुंच सकता है। डिफ़ॉल्ट 32 * 1024 * 1024 (32 एमबी) है।

RUBY_GC_OLDMALLOC_LIMIT

एक पूरी कचरा संग्रहण कॉल करने से पहले पुरानी पीढ़ी तक पहुंच सकता है। डिफ़ॉल्ट 16 * 1024 * 1024 (16 एमबी) है।

RUBY_GC_OLDMALLOC_LIMIT_GROWTH_FACTOR

वृद्धि का गुणांक old_malloc_limit है। डिफ़ॉल्ट 1.2 है।

RUBY_GC_OLDMALLOC_LIMIT_MAX

अधिकतम जो पुराना_मॉलोक_लिमिट हो सकता है। डिफ़ॉल्ट 128 * 1024 * 1024 (128MB) है।

मेमोरी लीक पर नज़र रखने के लिए ऑब्जेक्टस्पेस क्लास

रूबी 2.1 ट्रैकिंग स्थितियों के लिए कई उपकरण जोड़ता है जब हम पुरानी / बड़ी वस्तुओं के लिंक छोड़ देते हैं, जिससे उन्हें कचरा कलेक्टर तक पहुंच नहीं मिलती है।



अब हमारे पास किसी वस्तु का स्थान निर्धारित करने के लिए कई तरीके हैं:

 require "objspace" module Example class User def initialize(first_name, last_name) @first_name, @last_name = first_name, last_name end def name "#{@first_name} #{@last_name}" end end end ObjectSpace.trace_object_allocations do obj = Example::User.new("Arthur", "Dent").name ObjectSpace.allocation_sourcefile(obj) #=> "example.rb" ObjectSpace.allocation_sourceline(obj) #=> 10 ObjectSpace.allocation_class_path(obj) #=> "Example::User" ObjectSpace.allocation_method_id(obj) #=> :name ObjectSpace.allocation_generation(obj) #=> 6 end
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एलोकेशन_जनरेशन विधि द्वारा लौटाया गया नंबर, कचरा संग्रह की संख्या है जो उस समय पारित किया गया था जब ऑब्जेक्ट बनाया गया था। इस प्रकार, यदि यह संख्या छोटी है, तो अनुप्रयोग के प्रारंभ के दौरान ऑब्जेक्ट बनाया गया था।



एक ब्लॉक ट्रांसफर के साथ ट्रेस_बिजट_ऑलोकेशन का उपयोग करने के लिए एक ट्रेस के रूप में ट्रेस_बजेक्ट_ऑलोकेशन_स्टार्ट और ट्रेस_बोकेशन_ऑलोकेशन_स्टॉप तरीके भी हैं, और ऑब्जेक्ट्स के प्लेसमेंट के बारे में रिकॉर्ड किए गए डेटा को छोड़ने के लिए ट्रेस_बजेक्ट_ऑलोकेशन_क्लेयर।



इसके अलावा, आप इसे और न केवल एक फ़ाइल या लाइन में JSON प्रारूप में आगे के विश्लेषण या दृश्य के लिए जानकारी दे सकते हैं।

 require "objspace" ObjectSpace.trace_object_allocations do puts ObjectSpace.dump(["foo"].freeze) end
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

लाएगा

 { "address": "0x007fd122123f40", "class": "0x007fd121072098", "embedded": true, "file": "example.rb", "flags": { "wb_protected": true }, "frozen": true, "generation": 6, "length": 1, "line": 4, "references": [ "0x007fd122123f68" ], "type": "ARRAY" }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ढेर पर सभी मेमोरी के बारे में जानकारी प्राप्त करने के लिए ObjectSpace.dump_all विधि का उपयोग करना भी संभव है।

 require "objspace" ObjectSpace.trace_object_allocations_start # do things ... ObjectSpace.dump_all(output: File.open("heap.json", "w"))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इन दोनों तरीकों का उपयोग ऑब्जेक्ट आवंटन ट्रेसिंग को सक्रिय किए बिना किया जा सकता है, लेकिन कम जानकारी प्राप्त की जाएगी।



अंत में, ObjectSpace.reachable_objects_from_root विधि है, जो ObjectSpace.reachable_objects_from विधि के समान है, लेकिन यह एप्लिकेशन रूट से कोई तर्क और कार्य नहीं करता है। इस पद्धति की एक विशेषता है - यह एक हैश लौटाता है, जो चाबियों द्वारा पहुंचते समय, पहचान के लिए उनकी तुलना करता है, इसलिए पहुंच के लिए आपको न केवल समान पंक्तियों की आवश्यकता होती है, बल्कि हश में ही ऑब्जेक्ट ऑब्जेक्ट के साथ समान ऑब्जेक्ट्स होते हैं। सौभाग्य से, आप इसे प्राप्त कर सकते हैं:

 require "objspace" reachable = ObjectSpace.reachable_objects_from_root reachable = {}.merge(reachable) # workaround compare_by_identity reachable["symbols"] #=> ["freeze", "inspect", "intern", ...
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस पर पहला भाग पूरा हो गया है, अगला कुछ दिनों में होगा, इसमें शोधन, नए रूबीज, लैम्ब्डा में बदलाव और बहुत कुछ होगा।



भाग दो भाग तीन