रूबी 2.1 से हम क्या उम्मीद कर सकते हैं?

कुछ दिन पहले, रूबी समुदाय के प्रमुख लोगों में से एक, कॉन्स्टेंटिन हासे ने रूबी 2.1 के पूर्वावलोकन संस्करण की घोषणा पर एक ब्लॉग पोस्ट किया था। संस्करण 2.0 और 2.1 के बीच परिवर्तन इसकी प्रस्तुति को पढ़ने के लिए पर्याप्त जमा हुआ है, और बेहतर - रूसी में।

नायब: बेशक, रूबी 2.1 में पिछले संस्करण की सभी महान विशेषताएं हैं - 2.0। पिछले संस्करणों में परिवर्तन का उल्लेख नहीं किया जाएगा।

शोधन तंत्र

यह ज्ञात है कि रूबी 2.0 में एक परिशोधन तंत्र पेश किया गया है। इस तंत्र का कार्यान्वयन काफी विवादास्पद था, इसलिए, संस्करण 2.0 में इसकी कार्यक्षमता कुछ सीमित थी और प्रयोगात्मक के रूप में चिह्नित थी।

यह याद रखने योग्य है कि शोधन आपको एकल रूबी फ़ाइल के भीतर डिकॉय पैच लागू करने की अनुमति देता है:

module Foo refine String do def foo self + "foo" end end end using Foo puts "bar".foo 

इस फ़ाइल के बाहर, String वर्ग के उदाहरण foo विधि का जवाब नहीं देंगे।

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

 module Foo refine String do def foo self + "foo" end end end module Bar using Foo puts "bar".foo end 

यह ध्यान रखना महत्वपूर्ण है कि अति-उत्साही परिशोधन काफी भ्रमित कोड लिखने के लिए नेतृत्व कर सकते हैं। कुछ रूबी कार्यान्वयन के डेवलपर्स ने पहले ही कहा है कि वे शोधन का समर्थन करने से इनकार कर सकते हैं।

दशमलव शाब्दिक

जब रूबी के साथ काम करते हैं, तो आप देख सकते हैं कि फ्लोटिंग पॉइंट वैल्यू सबसे अच्छा व्यवहार नहीं करते हैं जब गणना उन पर की जाती है जो दशमलव अंशों के साथ काम करने से परिचित हैं:

 irb(main):001:0> 0.1 * 3 => 0.30000000000000004 

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

रूबी का नया संस्करण दशमलव और तर्कसंगत अंशों का वर्णन करने के लिए प्रत्यय r का परिचय देता है:

 irb(main):001:0> 0.1r => (1/10) irb(main):002:0> 0.1r * 3 => (3/10) 

अपरिवर्तनीय तार

यदि कोड में एक पंक्ति घोषणा होती है, तो हर बार कोड वाली लाइन निष्पादित होती है, रूबी कक्षा String की एक नई वस्तु बनाती है। यह लाइनों की उत्परिवर्तन के कारण है। ऐसे मामलों में, पात्र बहुत अधिक कुशलता से व्यवहार करते हैं, क्योंकि वे केवल एक बार आरंभिक होते हैं। हालाँकि, किसी वर्ण को स्ट्रिंग से तुलना करने के लिए, आपको स्ट्रिंग को वर्ण या वर्ण से स्ट्रिंग में बदलने की आवश्यकता है। ऐसे परिवर्तनों का प्रदर्शन एक जोखिम भरा ऑपरेशन है जो एक DoS हमले के लिए एक संभावित अवसर को खोलता है, क्योंकि कचरा संग्रह के दौरान वर्णों को मुक्त नहीं किया जाता है, और किसी भी चरित्र को स्ट्रिंग में बदलने से एक नई रेखा बनती है।

इस मामले में नकारात्मक परिणामों से खुद को बचाने का एकमात्र तरीका स्ट्रिंग को स्थिर के रूप में संग्रहीत और उपयोग करना है:

 class Foo BAR = "bar" def bar?(input) input == BAR end end 

अक्सर, उत्परिवर्तन से छुटकारा पाने के लिए, वे लाइन फ्रीजिंग करते हैं। किसी ऑब्जेक्ट को फ्रीज़ करना रूबी कोड के हिस्से को बदलने से रोकता है, लेकिन कोई प्रदर्शन सुधार नहीं देता है:

 class Foo BAR = "bar".freeze def bar?(input) input == BAR end end 

यह हास्यास्पद और भारी लगता है। सौभाग्य से, रूबी 2.1 इस समस्या को हल करने के लिए एक नया वाक्यविन्यास प्रदान करता है:

 class Foo def bar?(input) input == "bar"f end end 

String वर्ग की एक अपरिवर्तनीय वस्तु उपरोक्त कोड में बनाई जाएगी, और जहां भी इसका उपयोग किया जाता है, इसे केवल एक बार आरंभ किया जाएगा।

यह संभव है कि इस तरह के एक वाक्यविन्यास अजीब लग सकता है। समान कोड के टुकड़े को फिर से लिखा जा सकता है:

 class Foo def bar?(input) input == %q{bar}f end end 

सामान्य तौर पर, arrix और hashes में प्रत्यय f लगाने का प्रश्न खुला रहता है।

अनिवार्य कुंजी तर्क

किसी कारण के लिए, रूबी 2.0 की घोषणा में आवश्यक मुख्य तर्कों का उल्लेख नहीं किया गया था। तो, रूबी 2.0 आवश्यक प्रमुख तर्क प्रस्तुत करता है:

 def foo(a: 10) puts a end foo(a: 20) # 20 foo # 10 

घोषित तरीकों के लिए इस दृष्टिकोण के साथ, आपको डिफ़ॉल्ट तर्क मूल्यों को निर्दिष्ट करना होगा। यह हमेशा संभव नहीं होता है, इसलिए रूबी 2.1 आपको आवश्यक मुख्य तर्क निर्दिष्ट करने की अनुमति देता है:

 def foo(a:) puts a end foo(a: 20) # 20 foo # ArgumentError: missing keyword: a 

विधि घोषणा रिटर्न विधि नाम

रूबी के पिछले संस्करणों में, def रिटर्न nil का उपयोग करते हुए एक विधि घोषणा।

 def foo() end # => nil 

अब यह व्यवहार बदल गया है और विधि नाम एक प्रतीक के रूप में वापस आ गया है:

 def foo() end # => :foo 

यह मेटाप्रोग्रामिंग और इस तरह के ट्रिक करने के लिए उपयोगी है। उदाहरण के लिए, क्या सभी जानते हैं कि private पद्धति तर्क ले सकती है?

 #     foo class Foo def foo end private :foo #  bar   def bar end end 

अब वह घोषणा की गई विधि का नाम देता है, आप आसानी से विधियों को निजी बना सकते हैं:

 #     foo  bar class Foo private def foo end private \ def bar end def baz end end 

स्ट्रिंग्स से एक्स्ट्रा बाइट्स निकालना

अब रूबी में अतिरिक्त बाइट्स को स्ट्रिंग्स से हटाने के लिए एक सुविधाजनक तरीका है:

 some_string.scrub("") 

सभी मौजूदा रूबी कार्यान्वयन के लिए इस पद्धति के लिए एक ही व्यवहार को प्राप्त करना मुश्किल था, इसलिए इसके लिए एक पुस्तकालय भी उपलब्ध है।

StringScanner कैप्शन नाम का समर्थन करता है

कई लोग मानक भाषा पुस्तकालय से StringScanner वर्ग को पसंद करते हैं। विशेष रूप से, इसका उपयोग पटरियों को पार्स करने के लिए रेल्स में किया जाता है। सिनात्रा 2.0 वही करेगी।

संस्करण 1.9 में नामित कैप्चर के लिए समर्थन जोड़ा गया है, लेकिन StringScanner ने उनका समर्थन नहीं किया:

 require 'strscan' s = StringScanner.new("foo") s.scan(/(?<bar>.*)/) puts s[:bar] 

रूबी 2.0 में, ऐसा कोड एक अपवाद फेंकता है:

 TypeError: no implicit conversion of Symbol into Integer 

लेकिन जब आप रूबी 2.1 पर चलते हैं, तो सब कुछ ठीक हो जाएगा:

 foo 

नेटवर्क इंटरफेस के साथ काम करें

अब आप Socket.getifaddrs विधि का उपयोग कर नेटवर्क इंटरफेस का उपयोग कर सकते हैं:

 require 'socket' Socket.getifaddrs.each do |i| puts "#{i.name}: #{i.addr.ip_address}" if i.addr.ip? end 

ऐसे कार्यक्रम के आउटपुट का एक उदाहरण:

 lo0: fe80::1%lo0 lo0: 127.0.0.1 lo0: ::1 en0: fe80::1240:f3ff:fe7e:594e%en0 en0: 192.168.178.30 en2: fe80::3e07:54ff:fe6f:147a%en2 

कंप्यूटिंग कार्यों के लिए संख्याओं के साथ तेजी से काम

रूबी 2.1 तेजी से होता है जब Bignum वर्ग में वस्तुओं के आंतरिक प्रतिनिधित्व के रूप में 128-बिट पूर्णांक का उपयोग करके बड़ी संख्या के साथ काम करता है। इसके अलावा, जीएनयू मल्टीपल प्रिसिजन अरिथमेटिक लाइब्रेरी का उपयोग अतिरिक्त प्रदर्शन को बढ़ावा देता है।

वर्चुअल मशीन बदल जाती है

अब रूबी वर्चुअल मशीन, ग्लोबल विधि कैश के उपयोग के साथ, फ़ंक्शन कॉल के स्थान पर कैशिंग प्रदर्शन करती है। इस बारे में अलग-अलग स्लाइड हैं।

RGenGC

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

वास्तव में, पुराने कलेक्टर गायब नहीं हुए हैं। आंतरिक और बाहरी रूबी सी प्रोग्रामिंग इंटरफ़ेस की सुविधाओं के कारण ऐसी चीजों को बदलना मुश्किल है।

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

नया कचरा संग्राहक केवल हल्की वस्तुओं के साथ काम करता है।

RubyGems अपडेट

RubyGems को संस्करण 2.2.0 का अद्यतन प्राप्त हुआ, जो कई छोटे सुधार लाता है।

कुछ भी नहीं हमेशा के लिए रहता है

यह मत भूलो कि हालिया रिलीज़ केवल एक प्रारंभिक संस्करण है, और उपरोक्त सभी बदल सकते हैं।