👨🏽‍⚖️ 👩🏾‍🏭 🎷 रूबी 2.1 विस्तार से (भाग 2) ⏪ 🤽🏼 👩🏻‍🎤

शोधन

शोधन (परिशोधन) अब प्रायोगिक विशेषताएं नहीं हैं और वेर्निंग प्रदर्शित नहीं करते हैं, और उनके कार्यान्वयन में कई विवरण जोड़े गए हैं जो उनके उपयोग को अधिक सुविधाजनक बनाते हैं।

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

module NumberQuery refine String do def number? match(/\A(0|-?[1-9][0-9]*)\z/) ? true : false end end end module Example using NumberQuery "42".number? #=> true end module Example "42".number? #=> #<NoMethodError: undefined method `number?' for "42":String> end

शोधन घोषणाएँ अब मॉड्यूल # शामिल का उपयोग करके विरासत में मिली हैं, अर्थात्। आप विभिन्न मॉड्यूलों को एक में परिभाषित कर सकते हैं और उन सभी को सक्रिय करके केवल इस मॉड्यूल के लिए कॉल कर सकते हैं।

 module BlankQuery refine Object do def blank? respond_to?(:empty?) ? empty? : false end end refine String do def blank? strip.length == 0 end end refine NilClass do def blank? true end end end module NumberQuery refine Object do def number? false end end refine String do def number? match(/\A(0|-?[1-9][0-9]*)\z/) ? true : false end end refine Numeric do def number? true end end end module Support include BlankQuery include NumberQuery end class User using Support # ... def points=(obj) raise "points can't be blank" if obj.blank? raise "points must be a number" unless obj.number? @points = obj end end

स्ट्रिंग # स्क्रब

अमान्य बाइट वाले तारों से निपटने में मदद करने के लिए रूबी 2.1 में स्ट्रिंग # स्क्रब विधि को जोड़ा गया था।

 # create a string that can't be sensibly printed # 'latin 1' encoded string with accented character string = "öops".encode("ISO-8859-1") # misrepresented as UTF-8 string.force_encoding("UTF-8") # and mixed with a UTF-8 character string = "¡#{string}!"

यह संभावना नहीं है कि आप सचेत रूप से इस तरह से लाइनें बनाएंगे (कम से कम मुझे उम्मीद है), लेकिन यह उन लाइनों के साथ होता है जो कई अलग-अलग प्रणालियों से गुजर चुके हैं।

यदि हमारे पास ऐसी "यात्रा" का केवल अंतिम परिणाम है, तो हम अब सभी गलत तरीके से एन्कोड किए गए वर्णों को पुनर्प्राप्त नहीं कर सकते हैं, लेकिन हम उन्हें कम से कम हटा सकते हैं:

 # replace with 'replacement character' string.scrub #=> "¡ ops!" # delete string.scrub("") #=> "¡ops!" # replace with chosen character string.scrub("?") #=> "¡?ops!" # yield to a block for custom replacement # (in this case the invalid bytes as hex) string.scrub {|bytes| "<#{bytes.unpack("H*").join}>"} #=> "¡<f6>ops!"

उसी परिणाम को वर्तमान एन्कोडिंग और अमान्य के साथ #encoding पद्धति को कॉल करके प्राप्त किया जा सकता है :: तर्क के रूप में प्रतिस्थापित करें:

 string.encode("UTF-8", invalid: :replace) #=> "¡ ops!" string.encode("UTF-8", invalid: :replace, replace: "?") #=> "¡?ops!"

Bignum / तर्कसंगत कक्षाओं में प्रदर्शन में सुधार

Bignum और तर्कसंगत कक्षाएं अब प्रदर्शन को बेहतर बनाने के लिए GNU मल्टीपल प्रिसिजन अरिथमेटिक लाइब्रेरी (GMP) का उपयोग करती हैं।

स्तर 4 ने $ सेफ को हटा दिया

$ SAFE = 4 को सेट करना रूबी को सैंडबॉक्स मोड में डालना और अविश्वास कोड को निष्पादित करने की अनुमति देना था। हालाँकि, यह विशेष रूप से प्रभावी नहीं था क्योंकि यह दुभाषिया भर में बिखरे हुए कोड की काफी मात्रा की आवश्यकता थी, और लगभग कभी भी उपयोग नहीं किया गया था, यही कारण है कि इसे अंततः हटा दिया गया था।

 $SAFE = 4 #=> #<ArgumentError: $SAFE=4 is obsolete>

clock_gettime

रूबी ने.c.c__gettime पद्धति का उपयोग करके घड़ी_गेटटाइम () सिस्टम फ़ंक्शन को एक्सेस किया, जो विभिन्न दिनांक मानों तक पहुंच प्रदान करता है। पहले तर्क के रूप में, टाइम आईडी को विधि से पास किया जाना चाहिए:

 Process.clock_gettime(Process::CLOCK_REALTIME) #=> 1391705719.906066

प्रक्रिया :: CLOCK_REALTIME पास करके, आपको वापसी मान के रूप में एक यूनिक्स टाइमस्टैम्प मिलता है। यह Time.now.to_f के अनुरूप भी होगा, लेकिन बिना टाइम ऑब्जेक्ट बनाए, इसलिए यह थोड़ा तेज़ चलेगा।

Process.clock_gettime का उपयोग "नीरस" घड़ी तक पहुंचने के लिए भी किया जा सकता है, जो सिस्टम घड़ी के अनुवाद पर निर्भर नहीं करता है। इसका उपयोग महत्वपूर्ण समय मापन या बेंचमार्किंग के लिए किया जा सकता है।

हालाँकि, एक नीरस घड़ी का मूल्य केवल तभी समझ में आता है जब एक ही समान चिह्न के साथ तुलना की जाती है:

 start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) sleep 1 Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time #=> 1.0051147330086678

बेंचमार्किंग के लिए इस्तेमाल किया जा सकने वाला एक और मूल्य CLOCK_PROCESS_CPUTIME_ID है। यह एक मोनोटोन घड़ी के समान काम करता है, अर्थात लगातार बढ़ रहा है, लेकिन अंतर यह है कि यह केवल तब बढ़ता है जब सीपीयू कुछ काम करता है। यह चिह्न अन्य समान चिह्न की तुलना में भी समझ में आता है।

 start_time = Process.clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID) sleep 1 Process.clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID) - start_time #=> 0.005225999999999981

ये तीन घड़ी मूल्य, वास्तविक, नीरस और प्रोसेसर, हमेशा उपलब्ध हैं। आपके द्वारा उपयोग की जाने वाली प्रणाली के आधार पर, अन्य प्रकार की घड़ियों तक पहुंचना संभव है, यह जानने के लिए, संबंधित दस्तावेज पढ़ें।

किसी विशेष प्रकार की घड़ी की उपलब्धता की उपलब्धता की जांच करने के लिए, यह जांचने के लिए पर्याप्त है कि संबंधित स्थिरांक परिभाषित है।

 Process.const_defined?(:CLOCK_PROCESS_CPUTIME_ID) #=> true Process.const_defined?(:CLOCK_THREAD_CPUTIME_ID) #=> false

Process.clock_getres विधि भी उपलब्ध है, जो आपको एक विशेष प्रकार की घड़ी द्वारा प्रदान किए गए रिज़ॉल्यूशन का पता लगाने की अनुमति देती है।

RubyGems अपडेट

RubyGems के एम्बेडेड संस्करण को 2.2 संस्करण में अपडेट किया गया है। RubyGems में सभी बुंदलर सुविधाओं का समर्थन करने के लिए काम के हिस्से के रूप में Gemfile.lock समर्थन को Gemfile समर्थन में जोड़ा गया है।

मणि स्थापित करने के लिए --file (या -g) विकल्प के लिए अब निर्भरता फ़ाइल की आवश्यकता नहीं होती है, यह स्वचालित रूप से एक Gemfile की उपस्थिति का पता लगाता है। मणि स्थापित भी Gemfile.lock उत्पन्न करेगा अगर यह पहले से ही नहीं बनाया गया है, और अगर यह पहले से ही बनाया गया है, तो इसमें दिए गए संस्करणों पर विचार करें।

 $ ls Gemfile $ gem install -g Fetching: going_postal-0.1.4.gem (100%) Installing going_postal (0.1.4) $ ls Gemfile Gemfile.lock

इतिहास फ़ाइल में परिवर्तनों की पूरी सूची पाई जा सकती है।

हटाए गए अप्रचलित सुविधाओं को रेक

अंतर्निहित रेक को 10.1.0 संस्करण में अद्यतन किया गया है, जिसमें कई हटाए गए फीचर हटा दिए गए हैं। रेक के पुराने संस्करणों में, इन विशेषताओं के बारे में लंबे समय से चेतावनी जारी की गई है, इसलिए कोई संगतता मुद्दे नहीं होने चाहिए।

यदि आपको अधिक विवरणों की आवश्यकता है, तो रेक संस्करणों 10.0.3 और 10.1.0 में परिवर्तनों की पूरी सूची देखें।

RDoc टेम्पलेट अपडेट करें

रूबी में अब RDoc संस्करण 4.1 शामिल है, जिसमें पहुंच के संदर्भ में कुछ सुधार के साथ डिफ़ॉल्ट टेम्पलेट का अपडेट शामिल है। इतिहास फ़ाइल में परिवर्तनों की पूरी सूची पाई जा सकती है।

प्रक्रिया का नाम

एक नई Process.setproctitle पद्धति जोड़ी गई है जो आपको $ 0 चर का उपयोग किए बिना प्रक्रिया का नाम सेट करने की अनुमति देती है। $ 0 का मूल मान प्राप्त करने के लिए Process.argv0 विधि को भी जोड़ा गया है।

उदाहरण के लिए, आपके पास निम्न पृष्ठभूमि स्क्रिप्ट है:

 data.each_with_index do |datum, i| Process.setproctitle("#{Process.argv0} - job #{i} of #{data.length}") process(datum) end

तब जब आप पीएस शुरू करते हैं तो आपको निम्नलिखित कुछ दिखाई देगा:

 $ ps PID TTY TIME CMD 339 ttys000 0:00.23 -bash 7321 ttys000 0:00.06 background.rb - job 10 of 30

जमे हुए प्रतीक

प्रतीक वस्तुएं अब पूर्णांक और वास्तविक संख्याओं की एक कंपनी बनाती हैं, जो "फ्रोजन" (जमी हुई) वस्तुएं हैं।

 :foo.frozen? #=> true :foo.instance_variable_set(:@bar, "baz") #=> #<RuntimeError: can't modify frozen Symbol>

यह परिवर्तन रूबी के भविष्य के संस्करणों में ऐसी वस्तुओं के लिए कचरा संग्रह में सुधार करने के लिए किया गया था।

स्कोप लीक तय

निजी, संरक्षित, सार्वजनिक, या मॉड्यूल_फंक्शन कीवर्ड का उपयोग करते समय एक स्ट्रिंग में तर्कों के बिना eval, example_eval या मॉड्यूल_eval का उपयोग करके निष्पादित किया जाता है, विधि का दायरा मूल प्रवाह के लिए "प्रवाह", अर्थात्। नीचे दिए गए उदाहरण में, फू विधि निजी होगी:

 class Foo eval "private" def foo "foo" end end

संस्करण 2.1 में, यह तय हो गया है और फू खुले रहेंगे।

#untrusted? अब # परित्यक्त के लिए एक उपनाम है?

रूबी में इससे पहले, वस्तुओं को अविश्वास के रूप में चिह्नित करने के दो तरीके थे, जिनमें से पहले #tainst; #taint और #untaint तरीके शामिल थे, दूसरे में #untrusted ;, #untrust और #trust शामिल हैं। वे उसी तरह काम करते हैं, लेकिन वस्तुओं के लिए अलग झंडे सेट करते हैं।

अब इन विधियों को एकीकृत किया गया है और एक ही झंडे को सेट किया गया है, जिसमें #tainted अधिक बेहतर है? और कंपनी, और जब फोन #untrusted? और अन्य लोगों को दिखाई देंगे।

 string = "foo" string.untrust string.tainted? #=> true

एक चेतावनी प्रदर्शित करेगा

 example.rb:2: warning: untrust is deprecated and its behavior is same as taint

मेमनों में लौटें

लैम्ब्डा ब्लॉक से अलग हैं और उस रिटर्न में प्रोक ऑब्जेक्ट एक लैम्ब्डा से कंट्रोल लौटाते हैं, न कि कॉलिंग मेथड से। हालांकि, एक अपवाद है यदि लंबोदर को पारित किया जाता है और उपज के साथ बुलाया जाता है। यह अब तय किया गया है।

 def call_with_yield yield end def test call_with_yield(&lambda {return "hello from lambda"}) "hello from method" end test #=> "hello from method"

ऊपर दिया गया उदाहरण रूबी <= 2.0.0 के लिए "लंबो से हैलो" का उत्पादन करेगा।

इंटरफ़ेस पते

अब आप Socket.getifaddrs विधि का उपयोग करके सिस्टम में नेटवर्क इंटरफेस का विवरण प्राप्त कर सकते हैं। यह सॉकेट की एक सरणी देता है :: ifaddr ऑब्जेक्ट।

 require "socket" info = Socket.getifaddrs.find do |ifaddr| (ifaddr.flags & Socket::IFF_BROADCAST).nonzero? && ifaddr.addr.afamily == Socket::AF_INET end info.addr.ip_address #=> "10.0.1.2"

StringScanner में नामित समूह का समर्थन

StringScanner # [] अब प्रतीक वस्तुओं को तर्क के रूप में लेता है और संबंधित नामित समूहों के मूल्यों को वापस करता है।

 require "strscan" def parse_ini(string) scanner = StringScanner.new(string) current_section = data = {} until scanner.eos? scanner.skip(/\s+/) if scanner.scan(/;/) scanner.skip_until(/[\r\n]+/) elsif scanner.scan(/\[(?<name>[^\]]+)\]/) current_section = current_section[scanner[:name]] = {} elsif scanner.scan(/(?<key>[^=]+)=(?<value>.*)/) current_section[scanner[:key]] = scanner[:value] end end data end

YAML.safe_load

YAML (या अधिक सटीक रूप से साइक, अंतर्निहित कार्यान्वयन) में, safe_load विधि जोड़ी गई थी। डिफ़ॉल्ट रूप से, निम्न वर्गों को deserialized किया जा सकता है: TrueClass, FalseClass, NilClass, Numeric, String, Array और Hash। अन्य वर्गों को डिसेर्बलाइज करने के लिए, यदि आप उनकी सुरक्षा के बारे में सुनिश्चित हैं, तो आपको उन्हें एक तर्क के रूप में पारित करने की आवश्यकता है।

यदि एक अनसुलझे वर्ग ऑब्जेक्ट पास किया जाता है, तो एक साइक :: DisallowedClass अपवाद को फेंक दिया जाएगा, जिसे YAML :: DisallowedClass के रूप में भी फेंका जा सकता है।

 require "yaml" YAML.safe_load(":foo: 1") #=> #<Psych::DisallowedClass: Tried to load unspecified class: Symbol> YAML.safe_load(":foo: 1", [Symbol]) #=> {:foo=>1}

Resolv में MDNS और LOC रिकॉर्ड के लिए समर्थन

Resolv DNS लाइब्रेरी को मल्टीकास्ट DNS लुकअप के लिए बुनियादी समर्थन मिला है। यह निरंतर अनुरोधों का समर्थन नहीं करता है, और सेवा खोज नहीं कर सकता है, लेकिन यह अभी भी एक बहुत ही सुविधाजनक नवाचार है (DNS सेवा डिस्कवरी के लिए पूर्ण समर्थन के लिए, dnssd मणि का प्रयास करें)।

 require "resolv" resolver = Resolv::MDNS.new resolver.getaddress("example.local") #=> #<Resolv::IPv4 10.0.1.2>

Resolv- प्रतिस्थापित लाइब्रेरी लिंक आपको रूबी में अधिकांश नेटवर्क पुस्तकालयों के साथ mDNS नामों का उपयोग करने की अनुमति देता है।

 require "resolv-replace" require "net/http" Resolv::DefaultResolver.replace_resolvers([Resolv::Hosts.new, Resolv::MDNS.new]) Net::HTTP.get_response(URI.parse("http://example.local")) #=> #<Net::HTTPOK 200 OK readbody=true>

रिज़ॉल्व को DNS LOC रिकॉर्ड्स को क्वेरी करने की क्षमता भी मिली।

 require "resolv" dns = Resolv::DNS.new # find.me.uk has LOC records for all UK postcodes resource = dns.getresource("W1A1AA.find.me.uk", Resolv::DNS::Resource::IN::LOC) resource.latitude #=> #<Resolv::LOC::Coord 51 31 6.827 N> resource.longitude #=> #<Resolv::LOC::Coord 0 8 37.585 W>

अंत में, Resolv में अंतिम परिवर्तन, आप अब Resolv :: DNS # fetch_resource विधि का उपयोग करके पूर्ण DNS संदेश प्राप्त कर सकते हैं।

 require "resolv" dns = Resolv::DNS.new dns.fetch_resource("example.com", Resolv::DNS::Resource::IN::A) do |reply, reply_name| reply #=> #<Resolv::DNS::Message:0x007f88192e2cc0 @id=55405, @qr=1, @opcode=0, @aa=0, @tc=0, @rd=1, @ra=1, @rcode=0, @question=[[#<Resolv::DNS::Name: example.com.>, Resolv::DNS::Resource::IN::A]], @answer=[[#<Resolv::DNS::Name: example.com.>, 79148, #<Resolv::DNS::Resource::IN::A:0x007f88192e1c80 @address=#<Resolv::IPv4 93.184.216.119>, @ttl=79148>]], @authority=[], @additional=[]> reply_name #=> #<Resolv::DNS::Name: example.com.> end

सॉकेट क्लास त्रुटि संदेश

सॉकेट पते त्रुटि संदेशों में जोड़े गए हैं।

 require "socket" TCPSocket.new("localhost", 8080) #=> #<Errno::ECONNREFUSED: Connection refused - connect(2) for "localhost" port 8080>

त्वरित हैश # शिफ्ट

हैश # शिफ्ट का प्रदर्शन काफी बढ़ गया है, जो कि रूबी 1.9 में पेश किए गए सुव्यवस्थित सम्मिलित के साथ मिलकर LRU कैश को लागू करना संभव बनाता है।

 class LRUCache def initialize(size) @size, @hash = size, {} end def [](key) @hash[key] = @hash.delete(key) end def []=(key, value) @hash.delete(key) @hash[key] = value @hash.shift if @hash.size > @size end end

कतार, SizedQueue, और ConditionVariable कक्षाओं के प्रदर्शन में सुधार

क्यू (पूर्व में रूबी में कार्यान्वित) को लागू करके कतार, SizedQueue और ConditionVariable वर्गों को गति दी गई है।

टाइमआउट में एक आंतरिक अपवाद का अवरोधन

अब ब्लॉक निष्पादन को बाधित करने के लिए टाइमआउट वर्ग के अंदर उपयोग किए गए अपवादों को पकड़ना असंभव हो गया है। यह आंतरिक कार्यान्वयन का एक विवरण है, जबकि बाहरी अपवाद टाइमआउट :: त्रुटि अपरिवर्तित रहती है और इसे पकड़ा जा सकता है।

 require "timeout" begin Timeout.timeout(1) do begin sleep 2 rescue Exception # no longer swallows the timeout exception end end rescue StandardError => e e #=> #<Timeout::Error: execution expired> end

सेट

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

 require "set" a = Set[1,2,3] b = Set[3,4,5] c = Set[4,5,6] a.intersect?(b) #=> true b.intersect?(c) #=> true a.intersect?(c) #=> false a.disjoint?(b) #=> false b.disjoint?(c) #=> false a.disjoint?(c) #=> true

सेट पर एक और महत्वपूर्ण परिवर्तन यह है कि #to_set पद्धति ऑब्जेक्ट को स्वयं लौटाएगी, न कि बनाई गई प्रतिलिपि।

 require "set" set = Set["foo", "bar", "baz"] set.object_id #=> 70286489985620 set.to_set.object_id #=> 70286489985620

सुव्यवस्थित वेबब्रिक रिस्पांस प्रोसेसिंग

अब WEBrick से HTTP प्रतिक्रिया का शरीर किसी भी ऑब्जेक्ट को #read और #readpartial तरीकों से असाइन किया जा सकता है। पहले, ये केवल IO या स्ट्रिंग ऑब्जेक्ट हो सकते हैं। नीचे दिया गया उदाहरण एक वर्ग को लागू करता है जो 10 सेकंड के लिए हर सेकंड प्राप्त प्रतिक्रिया को प्रदर्शित करता है।

 require "webrick" class EnumeratorIOAdapter def initialize(enum) @enum, @buffer, @more = enum, "", true end def read(length=nil, out_buffer="") return nil unless @more until (length && @buffer.length >= length) || !fill_buffer; end if length part = @buffer.slice!(0, length) else part, @buffer = @buffer, "" end out_buffer.replace(part) end def readpartial(length, out_buffer="") raise EOFError if @buffer.empty? && !fill_buffer out_buffer.replace(@buffer.slice!(0, length)) end private def fill_buffer @buffer << @enum.next rescue StopIteration @more = false end end server = WEBrick::HTTPServer.new(Port: 8080) server.mount_proc "/" do |request, response| enum = Enumerator.new do |yielder| 10.times do sleep 1 yielder << "#{Time.now}\r\n" end end response.chunked = true response.body = EnumeratorIOAdapter.new(enum) end trap(:INT) {server.shutdown} server.start

न्यूमेरिक # स्टेप

न्यूमेरिक क्लास का # स्टेप तरीका अब स्थितियुक्त तर्कों के बजाय: और से: तक के नाम तर्कों को ले सकता है। से: तर्क वैकल्पिक है; यदि यह निर्दिष्ट नहीं है, तो अनुक्रम अनंत होगा। स्थैतिक तर्कों के साथ, यह निल को पहले तर्क के रूप में निर्दिष्ट करके प्राप्त किया जा सकता है।

 0.step(by: 5, to: 20) do |i| puts i end

लाएगा

 0 5 10 15 20

 0.step(by: 3) do |i| puts i end 0.step(nil, 3) do |i| puts i end

दोनों मामलों में

 0 3 6 9 12 ... and so on

आईओ

IO # कांस्टेंट IO के साथ अब आईओ :: SEEK_CUR, IO :: SEEK_END और IO :: SEEK_SET प्रतीक स्वीकार करता है: CUR ,: END और: SET ऑब्जेक्ट

दूसरे तर्क के रूप में, IO :: SEEK_DATA और IO :: SEEK_HOLE (या: DATA और: HOLE) को अब पास किया जा सकता है। जब निर्दिष्ट किया जाता है, तो पहला तर्क संक्रमण के लिए न्यूनतम डेटा / खाली स्थान के रूप में उपयोग किया जाता है।

 f = File.new("example.txt") # sets the offset to the start of the next data chunk at least 8 bytes long f.seek(8, IO::SEEK_DATA) # sets the offset to the start of the next empty space at least 32 bytes long f.seek(32, IO::SEEK_HOLE)

यह सभी प्लेटफार्मों पर समर्थित नहीं हो सकता है, जिन्हें IO.const_defined का उपयोग करके सत्यापित किया जा सकता है? (: SEEK_DATA) और IO.const_defined? (: SEEK_HOLE)।

अपवादों को फेंके बिना IO _nonblock का उपयोग करना

IO # read_nonblock और IO # write_nonblock विधियाँ एक नामांकित अपवाद ले सकती हैं: तर्क। यदि यह गलत (डिफ़ॉल्ट रूप से सत्य) पर सेट है, तो अपवाद अपवाद फेंकने के बजाय त्रुटि पर संबंधित प्रतीक वस्तु वापस कर देंगे।

 require "socket" io = TCPSocket.new("www.example.com", 80) message = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: close\r\n\r\n" loop do IO.select(nil, [io]) result = io.write_nonblock(message, exception: false) break unless result == :wait_writeable end response = "" loop do IO.select([io]) result = io.read_nonblock(32, exception: false) break unless result next if result == :wait_readable response << result end puts response.lines.first

बाहरी ASCII-8BIT अगर IO आंतरिक एन्कोडिंग की उपेक्षा करता है

यदि आप डिफ़ॉल्ट रूप से आंतरिक और बाहरी एन्कोडिंग निर्दिष्ट करते हैं, तो रूबी बाहरी एन्कोडिंग से आंतरिक में परिवर्तित हो जाएगी। अपवाद तब होता है जब बाहरी एन्कोडिंग ASCII-8BIT होता है, इस मामले में कोई रूपांतरण नहीं होता है।

यदि एक तर्क के रूप में IO पद्धति को एन्कोडिंग पास किया जाता है, तो एक ही अपवाद किया जाना चाहिए, लेकिन यह रूपांतरण नहीं किया गया था। बग को ठीक कर दिया गया है।

 File.read("example.txt", encoding: "ascii-8bit:utf-8").encoding #=> #<Encoding:ASCII-8BIT>

#include और #prepend अब खुले हैं

#Include और #prepend विधियां अब खुली हैं, यह मॉड्यूल और क्लास कक्षाओं पर लागू होती है।

 module NumberQuery def number? match(/\A(0|-?[1-9][0-9]*)\z/) ? true : false end end String.include(NumberQuery) "123".number? #=> true

 require "bigdecimal" module FloatingPointFormat def to_s(format="F") super end end BigDecimal.prepend(FloatingPointFormat) decimal = BigDecimal("1.23") decimal.to_s #=> "1.23" # rather than "0.123E1"

तीसरे भाग में मॉड्यूल और ऑब्जेक्ट कक्षाओं में नए तरीके, नेटवर्क कक्षाओं में बदलाव और मानक पुस्तकालय में अन्य अपडेट होंगे।

भाग एक भाग तीन

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