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

# सिंगिंगटन_क्लास विधि? मॉड्यूल / कक्षा के लिए

#Singleton_class; पद्धति को मॉड्यूल और क्लास कक्षाओं में जोड़ा गया है, जो कि आप उम्मीद करेंगे कि रिटर्न एक मेटा-क्लास (सिंगलटन) है

class Example singleton_class? #=> false class << self singleton_class? #=> true end end
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अधिक तार्किक मॉड्यूल # पूर्वजों

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

 Object.ancestors.include?(Object) #=> true Object.singleton_class.ancestors.include?(Object.singleton_class) #=> true
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ऑब्जेक्ट # सिंगलटन_मेथोड

# मैथोड और # आइंस्टीन_मेथोड के समान है, लेकिन केवल मेटा क्लास के तरीके लौटाता है

 class Example def self.test end def test2 end end # returns class method Example.singleton_method(:test) #=> #<Method: Example.test> # doesn't return instance method Example.singleton_method(:test2) #=> #<NameError: undefined singleton method `test2' for `Example'> # doesn't return inherited class method Example.singleton_method(:name) #=> #<NameError: undefined singleton method `name' for `Example'>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

 example = Object.new def example.test end example.singleton_method(:test) #=> #<Method: #<Object:0x007fc54997a610>.test>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

विधि # ओरिजिनल_नाम

#Original_name पद्धति मेथड और अनबाउंडमेथोड कक्षाओं में दिखाई दी है, जो बिना उपनाम के विधि नाम देता है।

 class Example def foo "foo" end alias bar foo end example = Example.new example.method(:foo).original_name #=> :foo example.method(:bar).original_name #=> :foo Example.instance_method(:bar).original_name #=> :foo
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Mutex # स्वामित्व में है?

म्यूटेक्स # स्वामित्व वाली विधि ? यह अब प्रायोगिक नहीं है, सामान्य तौर पर इसके बारे में कहने के लिए अधिक कुछ नहीं है।

हैश # रिजेक्ट

हैश के एक उपवर्ग में हैश # अस्वीकार पद्धति को कॉल करने से vorning आउटपुट होगा। रूबी 2.2 में, हैश उपवर्गों में #reject कॉल करने से एक नई हैश ऑब्जेक्ट वापस आएगा, न कि सबक्लास ऑब्जेक्ट। इसलिए, इस परिवर्तन की तैयारी में, अब तक एक चेतावनी जोड़ी गई है।

 class MyHash < Hash end example = MyHash.new example[:a] = 1 example[:b] = 2 example.reject {|k,v| v > 1}.class #=> MyHash
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

निम्नलिखित चेतावनी प्रदर्शित की जाएगी:

 example.rb:8: warning: copying unguaranteed attributes: {:a=>1, :b=>2} example.rb:8: warning: following atributes will not be copied in the future version: example.rb:8: warning: subclass: MyHash
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

रूबी 2.1.1 में, एक पूर्ण परिवर्तन गलती से शामिल हो गया था, जिसे हैश ऑब्जेक्ट वापस करता है और corroding उत्पन्न नहीं करता है, लेकिन 2.1.2 में यह वापस तय किया गया था।

वेक्टर # cross_product

क्रॉस_प्रोडक्ट पद्धति को वेक्टर वर्ग में जोड़ा गया है।

 require "matrix" Vector[1, 0, 0].cross_product(Vector[0, 1, 0]) #=> Vector[0, 0, -1]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

फ़िक्नम / बिग्नम #bit_length

पूर्णांक के संबंध में #bit_length को कॉल करने से बाइनरी सिस्टम में संख्या का प्रतिनिधित्व करने के लिए आवश्यक अंकों की संख्या वापस आ जाएगी।

 128.bit_length #=> 8 32768.bit_length #=> 16 2147483648.bit_length #=> 32 4611686018427387904.bit_length #=> 63
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

संख्याओं के पैक / अनपैक और बाइट प्रतिनिधित्व

सरणी # पैक और स्ट्रिंग # अनपैक तरीके अब Q_ / Q निर्देशों का उपयोग करके लंबी संख्या के बाइट प्रतिनिधित्व के साथ काम कर सकते हैं! और q_ / q।

 # output may differ depending on the endianness of your system unsigned_long_long_max = [2**64 - 1].pack("Q!") #=> "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF" signed_long_long_min = [-2**63].pack("q!") #=> "\x00\x00\x00\x00\x00\x00\x00\x80" signed_long_long_max = [2**63 - 1].pack("q!") #=> "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F" unsigned_long_long_max.unpack("Q!") #=> 18446744073709551615 signed_long_long_min.unpack("q!") #=> -9223372036854775808 signed_long_long_max.unpack("q!") #=> 9223372036854775807
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Dir.glob यौगिक वर्ण देता है

मैक ओएस एक्स पर एचएफएस प्लस फ़ाइल सिस्टम अलग-अलग वर्णों के साथ फ़ाइल नामों के लिए UTF8-MAC एन्कोडिंग का उपयोग करता है, उदाहरण के लिए, ई को यू और यू + 0301 के रूप में दर्शाया गया है, न कि केवल यू + 00 ई 9 ( कुछ अपवादों के साथ )। Dir.glob और Dir [] अब उन्हें वापस कंपाउंड वर्णों के साथ UTF8 तार में परिवर्तित करते हैं।

 File.write("composed_e\u{301}xample.txt", "") File.write("precomposed_\u{e9}xample.txt", "") puts Dir["*"].map(&:dump)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

 "composed_\u{e9}xample.txt" "example.rb" "precomposed_\u{e9}xample.txt"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

न्यूमेरिक # क्वो के लिए बेहतर प्रकार की कास्टिंग

न्यूमेरिक # क्वो विधि अब रिसीवर पर #to_r कॉल करती है, जिसे देशी न्यूमेरिक उपवर्ग को लागू करते समय व्यवहार में सुधार करना चाहिए। इसका अर्थ यह भी है कि यदि कास्ट नहीं किया जा सकता है, तो टाइप-इयररोड उठाया जाएगा, न कि एक आर्ग्यूमेंट एरर, जो संक्रमण के दौरान समस्या नहीं होनी चाहिए, क्योंकि TypeError ArgumentError का एक उपवर्ग है।

बंधन # स्थानीय_वर्णीय_गेट / _set / _defined?

बाइंडिंग वर्ग में, स्थानीय चर प्राप्त करने / स्थापित करने के तरीके दिखाई दिए हैं। यह उपयोगी हो सकता है यदि आपको वास्तव में नामित तर्क का उपयोग करने की आवश्यकता है जो आरक्षित कीवर्ड से मेल खाती है।

 def primes(begin: 2, end: 1000) [binding.local_variable_get(:begin), 2].max.upto(binding.local_variable_get(:end)).each_with_object([]) do |i, array| array << i unless (2...i).any? {|j| (i % j).zero?} end end primes(end: 10) #=> [2, 3, 5, 7]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

या यदि आप चर सेट करने के लिए हैश का उपयोग करना चाहते हैं, उदाहरण के लिए, टेम्पलेट निष्पादित करते समय:

 def make_binding(hash) b = TOPLEVEL_BINDING.dup hash.each {|k,v| b.local_variable_set(k, v)} b end require "erb" cover = %Q{<h1><%= title %></h1>\n<h2 class="big friendly"><%= subtitle %></h2>} locals = {:title => "Hitchhiker's Guide to the Galaxy", :subtitle => "Don't Panic"} ERB.new(cover).result(make_binding(locals)) #=> "<h1>Hitchhiker's Guide to the Galaxy</h1>\n<h2 class=\"big friendly\">Don't Panic</h2>"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

CGI वर्ग विधियाँ अब CGI :: Util मॉड्यूल से उपलब्ध हैं

CGI क्लास में url और html स्ट्रिंग्स से बचने के कई उपयोगी तरीके हैं। उन्हें CGI :: Util मॉड्यूल में पोर्ट किया गया है, जिसे अन्य वर्गों या लिपियों में शामिल किया जा सकता है।

 require "cgi/util" CGI.escape("hello world!") #=> "hello+world%21" include CGI::Util escape("hello world!") #=> "hello+world%21"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

डाइजेस्ट :: क्लास.फाइल कंस्ट्रक्टर को तर्क देता है

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

 require "digest" Digest::SHA2.new(512).hexdigest(File.read("example.txt")) #=> "f7fbba..."
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आप लिख सकते हैं:

 require "digest" Digest::SHA2.file("example.txt", 512).hexdigest #=> "f7fbba..."
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

नेट :: SMTP # rset

अब आप नेट :: SMTP # rset पद्धति का उपयोग करके RSET कमांड भेजकर SMTP लेनदेन को रद्द कर सकते हैं।

 require "net/smtp" smtp = Net::SMTP.start("some.smtp.server") notification = "Hi %s,\n ..." users.each do |user| begin smtp.mailfrom("noreply@example.com") smtp.rcptto(user.email) smtp.data(sprintf(notification, user.name)) rescue smtp.rset end end smtp.finish
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

open-uri डुप्लिकेट हेडर का समर्थन करता है

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

 require "open-uri" f = open("http://google.com") f.meta["set-cookie"].class #=> String f.metas["set-cookie"].class #=> Array f.metas["set-cookie"].length #=> 2
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Pathname के माध्यम से फ़ाइल में लिखना

फ़ाइलों को लिखने के लिए #write और #binwrite तरीकों को Pathname वर्ग में जोड़ा गया है।

 require "pathname" path = Pathname.new("test.txt").expand_path(__dir__) path.write("foo") path.write("bar", 3) # offset path.write("baz", mode: "a") # append
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Tempfile.create

Tempfile वर्ग में अब नई विधि के समान एक विधि है, लेकिन जब ऑब्जेक्ट कचरा एकत्र किया जाता है, तो फ़ाइल को हटाने के लिए एक अंतिम उपयोगकर्ता Tempfile ऑब्जेक्ट को वापस करने के बजाय, बनाएँ विधि फ़ाइल ऑब्जेक्ट को ब्लॉक में पास करती है, जिसके बाद फ़ाइल हटा दी जाती है।

 require "tempfile" path = nil Tempfile.create("example") do |f| f #=> #<File:/tmp/example20140428-16851-15kf046> path = f.path end File.exist?(path) #=> false
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

रिंडा में ब्रॉडकास्ट सपोर्ट

Rinda Ring क्लासेज अब ग्रुप एड्रेस को सुन / कनेक्ट कर सकती हैं।



नीचे 239.0.0.1 के बहुस्तरीय पते पर एक साधारण सेवा सुनने के लिए रिंडा का उपयोग करने का एक उदाहरण है

 require "rinda/ring" require "rinda/tuplespace" DRb.start_service tuple_space = Rinda::TupleSpace.new server = Rinda::RingServer.new(tuple_space, ["239.0.0.1"]) DRb.thread.join
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

सेवा पंजीकरण:

 require "rinda/ring" DRb.start_service ring_finger = Rinda::RingFinger.new(["239.0.0.1"]) tuple_space = ring_finger.lookup_ring_any tuple_space.write([:message_service, "localhost", 8080]) # start messaging service on localhost:8080
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

सेवा का पता प्राप्त करना:

 require "rinda/ring" DRb.start_service ring_finger = Rinda::RingFinger.new(["239.0.0.1"]) tuple_space = ring_finger.lookup_ring_any _, host, port = tuple_space.read([:message_service, String, Fixnum]) # connect to messaging service
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

मुझे स्ट्रिंग tuple_space = ring_finger.lookup_ring_any के साथ कुछ समस्याएं थीं और मुझे इसका उपयोग करना था:

 tuple_space = nil ring_finger.lookup_ring(0.01) {|x| break tuple_space = x}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

XMLRPC के लिए उन्नत HTTP विकल्प सेट करना

XMLRPC :: क्लाइंट # http एक नेट :: HTTP ऑब्जेक्ट का उपयोग क्लाइंट द्वारा कुछ कॉन्फ़िगरेशन विकल्पों को सेट करने के लिए किया जाता है जो सेटर्स के माध्यम से सेट नहीं किए जा सकते हैं।

 client = XMLRPC::Client.new("example.com") client.http.keep_alive_timeout = 30 # keep connection open for longer # use client ...
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

URI.encode_ / decode_www_form को मानक WHATWG में अपडेट किया गया

URI.encode_www_form और URI.decode_www_form विधियों को WHATWG मानक के अनुपालन के लिए अद्यतन किया गया है।



URI.decode_www_form अब नहीं मानता है ;



सीमांकक के रूप में, &



केवल डिफ़ॉल्ट सीमांकक है, लेकिन आप विभाजक को नामित तर्क के साथ सीमांकक मान सेट कर सकते हैं:।

 require "uri" URI.decode_www_form("foo=1;bar=2", separator: ";") #=> [["foo", "1"], ["bar", "2"]]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

URI.decode_www_form अब URI.encode_www_form के उत्पादन को सफलतापूर्वक डिकोड कर सकता है जब इसका मान शून्य होता है।

 require "uri" string = URI.encode_www_form(foo: 1, bar: nil, baz: 3) #=> "foo=1&bar&baz=3" URI.decode_www_form("foo=1&bar&baz=3") #=> [["foo", "1"], ["bar", ""], ["baz", "3"]]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

RbConfig :: SIZEOF

नई RbConfig :: SIZEOF विधि C प्रकारों का आकार लौटाती है।

 require "rbconfig/sizeof" RbConfig::SIZEOF["short"] #=> 2 RbConfig::SIZEOF["int"] #=> 4 RbConfig::SIZEOF["long"] #=> 8
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Syslog में लॉगिंग श्रेणी की स्थापना :: लकड़हारा

Syslog :: लकड़हारा, Syslog के लिए लॉगर-संगत इंटरफ़ेस, श्रेणियों को स्थापित करने की क्षमता है।

 require "syslog/logger" facility = Syslog::LOG_LOCAL0 logger = Syslog::Logger.new("MyApp", facility) logger.debug("test")
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

CSV.for बिना ब्लॉक के एन्यूमरेटर लौटाता है

CSV.foreach, जिसे एक ब्लॉक के बिना एक तर्क के रूप में कहा जाता है, एक एन्यूमरेटर लौटाता है, लेकिन जब लंबे समय तक उपयोग किया जाता है, तो इससे IOError का पता चलता है, यह तय हो गया था।

 require "csv" enum = CSV.foreach("example.csv") enum.next #=> ["1", "foo"] enum.next #=> ["2", "bar"] enum.next #=> ["3", "baz"]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Openssl bignum

OpenSSL :: BN.new अब न केवल तार को स्वीकार करता है, बल्कि तर्कों के रूप में पूर्णांक भी बनाता है।

 require "openssl" OpenSSL::BN.new(4_611_686_018_427_387_904) #=> #<OpenSSL::BN:0x007fce7a0c56e8>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आकार Enumerator.new तर्क किसी भी ऑब्जेक्ट को स्वीकार करता है।

Enumerator.new आकार तर्क को स्वीकार करता है, जो या तो पूर्णांक या #call विधि के साथ एक ऑब्जेक्ट हो सकता है। हालाँकि, 2.0.0 से पहले, विधि वास्तव में केवल पूर्णांक और प्रोक वस्तुओं के साथ काम करती थी। अब यह तय हो गया है और प्रलेखन में कहा गया है।

 require "thread" queue = Queue.new enum = Enumerator.new(queue.method(:size)) do |yielder| loop {yielder << queue.pop} end queue << "foo" enum.size #=> 1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

पुस्तकालय को हटा दिया गया

शाप मानक पुस्तकालय से हटा दिए गए हैं और एक रत्न के रूप में उपलब्ध है।

TSort में कक्षा के तरीके

TSort क्लास निर्भरता की सूची से कार्यों के निष्पादन के क्रम को निर्धारित करने में उपयोगी हो सकती है। हालांकि, इसका उपयोग करना काफी परेशानी भरा है, कुल के लिए आपको एक वर्ग लागू करने की आवश्यकता है जिसमें TSort, साथ ही #tsort_each_node और #tsort_each_child विधियाँ शामिल हैं।



लेकिन अब TSort, उदाहरण के लिए, हैश के साथ उपयोग करने के लिए अधिक सुविधाजनक हो गया है। उदाहरण विधियों के रूप में उपलब्ध विधियाँ अब मॉड्यूल में ही उपलब्ध हैं, दो कहलाने वाली वस्तुओं को स्वीकार करते हुए, एक को #tsort_each_node के लिए और दूसरी #tsort_each_child के प्रतिस्थापन के रूप में।

 require "tsort" camping_steps = { "sleep" => ["food", "tent"], "tent" => ["camping site", "canvas"], "canvas" => ["tent poles"], "tent poles" => ["camping site"], "food" => ["fish", "fire"], "fire" => ["firewood", "matches", "camping site"], "fish" => ["stream", "fishing rod"] } all_nodes = camping_steps.to_a.flatten each_node = all_nodes.method(:each) each_child = -> step, &b {camping_steps.fetch(step, []).each(&b)} puts TSort.tsort(each_node, each_child)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

उत्पादन होगा:

 stream fishing rod fish firewood matches camping site fire food tent poles canvas tent sleep
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

टीसीपी फास्ट ओपन

रूबी 2.1 टीसीपी फास्ट ओपन के लिए समर्थन जोड़ता है, अगर आपके सिस्टम पर उपलब्ध है। सिस्टम में इसकी उपस्थिति की जांच करने के लिए, आप स्थिरांक सॉकेट :: TCP_FASTOPEN और सॉकेट :: MSG_FASTOPEN के अस्तित्व की जांच कर सकते हैं।



सर्वर:

 require "socket" unless Socket.const_defined?(:TCP_FASTOPEN) abort "TCP Fast Open not supported on this system" end server = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM) server.setsockopt(Socket::SOL_TCP, Socket::TCP_FASTOPEN, 5) addrinfo = Addrinfo.new(Socket.sockaddr_in(3000, "localhost")) server.bind(addrinfo) server.listen(1) socket = server.accept socket.write(socket.readline)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ग्राहक:

 require "socket" unless Socket.const_defined?(:MSG_FASTOPEN) abort "TCP Fast Open not supported on this system" end socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM) socket.send("foo\n", Socket::MSG_FASTOPEN, Socket.sockaddr_in(3000, "localhost")) puts socket.readline socket.close
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

भाग एक भाग दो