रूबी: जानने के लिए धोखा देती है

तुरंत एक आरक्षण करें कि इस स्पॉइलर के तहत पाठ लेख के मुख्य "उद्देश्य" भाग से अलग है, क्योंकि यहां मेरी व्यक्तिगत राय और धारणा है।

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

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

कुछ चीजें हैं जो आप कभी-कभी रूबी और रेल के बारे में पा सकते हैं - मैं उन्हें स्पष्ट करने की कोशिश करूंगा।

यह ज्ञात है कि रूबी धीमी है। और यह बहस करना मुश्किल है, क्योंकि रूबी एक व्याख्या की गई भाषा है। और जो विशिष्ट है, सबसे अधिक बार मैं इसे उन लोगों से सुनता हूं जो पीएचपी में लिखते हैं (विशेष रूप से), जो व्याख्या करने योग्य भी है, और सिंथेटिक परीक्षणों में गति के मामले में समान स्तर पर है। सबसे अधिक संभावना है, ये पुराने संस्करणों की कुख्याति की प्रतिध्वनियाँ हैं। वास्तव में, मुझे रेल और सिम्फनी दोनों के साथ काम करना था - वास्तविक रेल अनुप्रयोगों पर यह समान स्तर के अनुकूलन के साथ तेज़ है (और दोनों कैशिंग सफलता की कुंजी है)। यदि आपको मेमोरी में गति और कॉम्पैक्टनेस की आवश्यकता है - कोडांतरक उपयोग में लिखें Node.js. लेकिन विरोधाभास यह है कि रूबिस्ट अक्सर इस पर लिखते हैं - जब यह वास्तव में उचित है। और बात यह है: न केवल काम की गति महत्वपूर्ण है, बल्कि आवेदन लिखने की गति भी है। और रूबी, और सब कुछ जो हर संभव तरीके से जीथब पर पाया जा सकता है, प्रोग्रामर की वास्तव में उच्च उत्पादकता प्राप्त करने में मदद करता है - जिसमें आवेदन को अनुकूलित करने की संभावनाएं शामिल हैं। और यह मत भूलो कि मुख्य भार और अड़चनें अक्सर डेटाबेस होते हैं, और वेब एप्लिकेशन व्यापार तर्क की एक परत हैं। और इस तरह की परत अच्छी तरह से तराजू।

रूबी डेवलपर्स के उच्च वेतन के बारे में एक अजीब कहानी अभी भी है, और दूसरी तरफ, कि रूबी पर बहुत कम काम है। आमतौर पर पीएचपी में बाजार के लिए औसत और उस पर काम की मात्रा के साथ वेतन की तुलना में। PHP में औसत वेतन स्तर क्लासिक "एक अस्पताल में औसत वेतन तापमान है।" यदि हम Yii / Symfony / Zend और Rails के विशेषज्ञों की तुलना करते हैं (आप पायथन में Django भी जोड़ सकते हैं), तो चित्र पूरी तरह से अलग होगा, अर्थात्: वेतन और बाजार का आकार दोनों लगभग समान हैं। वास्तव में, अच्छे प्रोग्रामर को अच्छा भुगतान किया जाता है। और क्या अधिक है, जब आप स्क्रैच से एक परियोजना पर ले जाते हैं - अक्सर मंच का विकल्प आपके और आपकी टीम पर निर्भर करता है, न कि ग्राहक / बॉस।

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

और निश्चित रूप से, रेल पर लेख के फोकस के बावजूद, और इस विशेष मंच की लोकप्रियता - रूबी रेल से बहुत दूर है।

किसी भी मामले में, मुझे यकीन है कि एक प्रोग्रामर को अपनी छोटी सी दुनिया में नहीं बैठना चाहिए जो उसके लिए भुगतान किया जाता है। इस अर्थ में, रूबी न केवल फिर से शुरू में एक +1 भाषा प्रदान करता है, बल्कि इसके ऊप फोकस और व्यापक मेटाप्रोग्रामिंग क्षमताओं के कारण, एक अनुभव जो विभिन्न भाषाओं और प्लेटफार्मों में उपयोगी होगा।

रूबी भाषा: विकास और विकास की संभावनाओं का इतिहास

# {Os_name} पर रूबी कैसे स्थापित करें?

लिंक खुद:

• जीत । DevKit को खोजने के लिए उसी लिंक का अनुसरण करें, जो डेटाबेस के साथ काम करने और मूल एक्सटेंशन स्थापित करने के लिए उपयोगी है
• रेल इंस्टॉलर रूबी + DevKit, Git, Rails, Bundler और SQLite को तुरंत Windows या MacOS पर स्थापित करेगा । रूबी, हालांकि, 1.9.3 है, और 2.0 के साथ इंस्टॉलर अभी भी अल्फा में है। ( जबर द्वारा सलाह दी गई)
• * निक्स - अपने रिपॉजिटरी या विरासत में खोजें

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

तुरंत ध्यान देने योग्य बात विकास का माहौल है। मैं JetBrains उत्पादों का प्रशंसक हूं, इसलिए मैं RubyMine की सलाह देता हूं, लेकिन चूंकि व्यावसायिक उत्पाद कुछ स्वाद के लिए हो सकता है, मुफ्त Aptana स्टूडियो । यदि प्रकाश पाठ संपादकों का उपयोग करना अधिक सुखद है, तो रूबी सिंटैक्स कई द्वारा समर्थित है।

रूबी इंटरैक्टिव मोड में एक ब्राउज़र में सीधे, आप tryruby.org पर कोशिश कर सकते हैं

संख्या, तार और यहां तक ​​कि शून्य भी शामिल है, वे सभी ऑब्जेक्ट क्लास से विरासत में मिले हैं। आप nil ?, क्लास, मेथड्स और response_to? जैसे तरीकों को कॉल कर सकते हैं?

'Hello world'.class # String nil.class # NilClass String.class # Class String.ancestors # [String, Comparable, Object, Kernel, BasicObject];    nil.nil? # true Object.new.methods #     Object;        -    nil.respond_to?('nil?') # true 

उत्तरार्द्ध के बारे में: यह बतख टाइपिंग के लिए महत्वपूर्ण है।

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

 a == b #  ,   a.==(b) #   .==() -   

विधि कॉल में, यदि आप अस्पष्टता नहीं होने पर कोष्ठकों को छोड़ सकते हैं

 nil.respond_to?('nil?') # true nil.respond_to? 'nil?' # true #  : if nil.respond_to? 'nil?' puts 'ok' end #  if 10.between? 1, 5 puts 'ok' end #        ,    if 10.between?(1, 50) && 20.between?(1, 50) puts 'ok' end 

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

 a = :nil? #  b = 'nil?' #  nil.respond_to? a # true nil.respond_to? b # true #  a == b # false a.to_s == b && a == b.to_sym # true;        

थोड़ा और पाउडर उनके साथ जुड़ा हुआ है:

 a = {:key1 => 'value1', :key2 => 'value2'} #   ( ) a = {key1: 'value1', key2: 'value2'} #   - ,    (Ruby >= 1.9.3) 

जब से विषय आया है:

 a = ['value1', 'value2'] #   s = 'String' s = "Double-quoted #{s}" # "Double-quoted String" - , ,  

और लिखने के लिए थोड़ा बदसूरत लेकिन सुविधाजनक तरीका के साथ डस्टिंग थीम को समाप्त करें:

 %w[value1 value2] # ["value1", "value2"] -   ,    %i[value1 value2] # [:value1, :value2] -  , (Ruby >= 2.0) s = %q(String) s = %Q(Double-quoted #{s}) %x('ls') #   `ls` #    %r(.*) == /.*/ # true;      

वैसे, रूबी के पास एक परिचित परिचित अर्धविराम है - यह एक पंक्ति में कई अभिव्यक्तियों को लिखने के काम में आ सकता है

 a = 10; puts a #    10 if nil.respond_to? 'nil?'; puts 'ok'; end #    -    

लेकिन सिंगल-लाइन अगर इस तरह लिखना बेहतर है

 puts 'ok' if nil.respond_to? 'nil?' 

यह अन्य भाषाओं से रूबी में और बीस मिनट में रूबी पढ़ने के लायक है, ठीक है, मुख्य दोस्त और सहायक माणिक-doc.org ।
बेस कक्षाओं के तरीकों को तुरंत देखना बेहतर है (सभी में - जो प्रत्येक_ और to_ हैं)।
स्ट्रिंग (यहाँ - पहली बात मैच, उप)
सरणी (मानचित्र, शामिल हों, शामिल हैं?)
हैश (has_key?; Has_value ?, मर्ज करें)
रूबी को एक साथ जीतना सरल सरल उदाहरण हैं । पहला गिराओ दूसरा गिराओ तीसरा गिराओ
यदि आप भोज जारी रखना चाहते हैं: रूबी पर जादू के चयन के साथ एक दिलचस्प जनता ।

रूबी में कक्षाएं काफी स्पष्ट हैं, लेकिन रूबी की शक्ति और आकर्षण उनके साथ काम करने की संभावनाओं में निहित है।

 class Foo def bar 10 #     -     end def baz(a) bar + 20 end end puts Foo.new.baz(10) # 30 

मॉड्यूल - यह एक अशुद्धता और एक नाम स्थान के रूप में दोनों का इलाज किया जा सकता है। अचानक? वास्तव में, यह कक्षाओं, विधियों और स्थिरांक का एक सेट है, और आप इसे अपने विवेक पर उपयोग कर सकते हैं।

 module B #    class Foo #  def initialize(k) @k = k end #      def bar; @k + 20 end end end puts B.Foo.new(3).bar # 23 puts B::Foo.new(3).bar # 23;   ,    module C #   def bar; @k + 25 end end class Foo include C; def initialize(k) @k = k end end puts Foo.new(3).bar # 28 

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

 class Foo def bar; 20 end end class Foo #  def baz; bar + 2 end end puts Foo.new.baz # 22 #   - :      Foo.class_eval do def bazz; bar + 3 end end puts Foo.new.bazz # 23 #        -     class Boo < Foo def boo; bar + 2 end end puts Boo.new.boo # 22 #   -    ,     a = Foo.new a.instance_eval do #   def booo; bar + 3 end end puts a.booo # 23 puts Foo.new.booo rescue puts 'error' # error; ,    puts a.respond_to? :booo # true puts Foo.new.respond_to? :booo # false #  -       def a.booboo bar + 4 end puts a.booboo # 24 

लेकिन अगर आप एक वर्ग के लिए Inst_eval करते हैं तो क्या होगा? बेशक, स्थिर तरीकों को जोड़ा जाएगा।

 class Foo def self.bar; 10 end #    end puts Foo.bar # 10 Foo.instance_eval do def baz; bar + 1 end end puts Foo.baz # 11 

आप इसके साथ चारों ओर खेल सकते हैं, मुख्य बात याद रखें - अपने पैरों का ख्याल रखें।

 class Foo def self.add_bar #   ,    self.class_eval do def bar; 'bar' end end end end puts Foo.new.respond_to? :bar # false class Boo < Foo #  add_bar #  end puts Boo.new.bar # bar #      ,      Foo.instance_eval do def add_baz self.class_eval do def baz; 'baz' end end end end class Baz < Foo add_baz end puts Baz.new.baz # baz 

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

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

 class Foo def bar #  @bar #   end def bar=(val) #  @bar = val #    end end 

क्या आप एक दर्जन या दो मापदंडों के लिए लिखने की कल्पना कर सकते हैं? रूबी में बहुत कोड है - घातक पाप: DRY । तो, आप इसे छोटा कर सकते हैं।

 class Foo attr_accessor :bar, :baz #     attr_reader :boo #   attr_writer :booo #   end 

अगला तैयार है? तब:
पेश है रूबी मेटाक्लासेस
मेट्रोपोग्रामिंग पैटर्न - बंदर पैचिंग के बारे में, छोटे - धमाके में पुन: उपयोग करें! , eval
हम इसमें शामिल हैं और विस्तार करते हैं

रूबी 2.0 नाम विधि तर्कों का समर्थन करता है:

 # bar  # barr     0 # baz -       true def foo(bar, barr = 0, baz: true) baz && bar + barr end p foo 1 # 1 p foo 1, 2 # 3 p foo 1, baz: false # false 

पिछले संस्करणों में, आप विशेषताओं को पार्स करके समान व्यवहार प्राप्त कर सकते हैं:

 def foo2(bar, *args) args end p foo2 1, 2, :baz => false # [2, {:baz=>false}] def foo3(bar, *args) options = args.extract_otions! #     args p bar p args p options end foo3 1, 2, 3, :baz => false # 1 # [2, 3] # {:baz=>false} 

रूबी 2.1 के साथ शुरू होकर, अब आप आवश्यक नाम तर्क जोड़ सकते हैं।

 def foo4(bar, baz:); bar end foo4 1 #  foo4 1, baz: 2 # 1 

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

 Foo.instance_eval do #    instance_eval     def baz; bar + 1 end end 

लेकिन एक और बुनियादी उदाहरण लेते हैं, यह भी है कि "रूबी में कैसे बनाया जाए":

 [1,2,3].each do |val| p val # , p(val) -  shortcut  puts(val.inspect) end #  1 2 3 #  ,    [1,2,3].each { |val| p val } #  1 2 3 [1,2,3].each_with_index { |val, i| puts val.to_s + ' ' + i.to_s } #   

यदि हम ब्लॉक को अपनी विधि में स्थानांतरित करना चाहते हैं:

 def foo puts yield #   puts yield + yield #  ,    end foo { 2 } # 2 4 def bar(&block) # ,    puts yield block #   end bar { 3 } # 3 

यह ध्यान दिया जाना चाहिए कि एक ब्लॉक हमेशा अंतिम पैरामीटर होता है, और यदि आपको कई ब्लॉकों को पास करने की आवश्यकता होती है, तो आपको उन्हें सामान्य पैरामीटर के रूप में पारित करने की आवश्यकता होती है, जिसका अर्थ है कि Proc.new, या लैम्ब्डा बनाना।

प्रोक वर्ग की एक वस्तु हमेशा ब्लॉक से प्राप्त की जाती है, लेकिन ब्लॉक स्वयं सिंटैक्स का हिस्सा है: हम इसे उस विधि से पारित कर सकते हैं जहां यह प्रोक बन जाएगा, हम इसे प्रोक निर्माता को पास कर सकते हैं, या लैम्ब्डा का उपयोग कर सकते हैं, लेकिन आप ब्लॉक को एक चर में नहीं लिख सकते।

 proc = Proc.new { |a| a - 1 } #   p proc.call(10) #9 p proc.class # Proc l = lambda { |a| a + 1 } #   p l.call(10) #11 p l.class # Proc new_l = ->(a) { a + 2 } #   (Ruby >= 2.0) p new_l.call(10) #12 

विभिन्न तरीकों से निर्मित प्रोक के व्यवहार में अंतर हैं, हमने लेख पढ़ा ।
यहाँ, रूबी में क्लोजर और ब्लॉक्स पार्स और लम्बे हैं
बंद के बारे में Habré पर, बंद करने के बारे में

रूबी में लिखने का रिवाज कैसा है, इसके लिए गीथहब पर एक पूरी गाइड है
संक्षेप में, अक्सर उपयोग किया जाता है:

• 2 स्थानों में इंडेंटेशन
• अंडरस्कोर विधि के साथ लोअरकेस विधि के नाम: def method_name
• पूंजीकृत वर्ग और मॉड्यूल नाम: वर्ग ClassName
• यदि विधि सही / गलत है, तो नाम एक प्रश्न के साथ समाप्त होना चाहिए (वही, शून्य?)
• यदि दो विधियाँ हैं, जिनमें से एक वस्तु को बदल देती है, और दूसरा एक नया लौटा देती है, पहला 'के साथ समाप्त होता है!' (उदाहरण के लिए, नीचे की ओर और नीचे की ओर! एक लाइन के लिए तरीके - पहला एक नया लौटाएगा, और दूसरा लाइन को खुद ही बदल देगा)
• इसके बजाय यदि ((मान) यह उर्फ ​​का उपयोग करना बेहतर है जब तक कि (मूल्य)
• एक एकल-पंक्ति ब्लॉक कोष्ठक {...} में लिया जाता है, और एक बहु-पंक्ति ब्लॉक डू ... एंड में होता है

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

• रूबीजम.ओआरजी के साथ (या माणिक-toolbox.com के माध्यम से) हमें क्या चुनना है, उदाहरण के लिए, json_pure - शुद्ध रूबी में JSON पार्सर (सी के बिना)
• रत्न स्थापित करें json_pure कंसोल दर्ज करें
• और हमारी आरबी फाइल में:

   require 'json/pure' #         ,   github 

सुविधा के लिए, निर्भरता प्रबंधन में एक बंडल है :

• मणि स्थापित बंडल
• बांधनेवाला
• जेमफाइल में हम निर्भरता दर्ज करते हैं:

   source 'https://rubygems.org' gem 'json_pure' 

• बंडल स्थापित करें
• और अपनी आरबी फाइल में

   require 'rubygems' require 'bundler/setup' 

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

रत्न खुद निश्चित रूप से रेल पर एक लेख में कवर किया जाएगा।

RubyGems - विस्तार
बुंडलर के साथ संस्करणों का प्रबंधन करना
पेश है मणि। भाग एक भाग दो
अपना पहला रत्न लिखना
RubyGems के लिए एक मणि बनाना
रत्न बनाना - एक मार्गदर्शक

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

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

सी रूबी एक्सटेंशन का परिचय
रूबी और सी। भाग 1 , भाग 2 , भाग 3 ।

एक सरल स्ट्रीम उदाहरण:

 thread = Thread.new do #    a = 0 1000000.times { a+= 1 } #      puts a #   end puts 'thread started' #       thread.join #     

कोड कंसोल "थ्रेड 100000 शुरू" के लिए आउटपुट होगा।

निचले स्तर के फाइबर थोड़ा अलग वाक्य-विन्यास प्रदान करते हैं जो आपको निष्पादन के अनुक्रम को नियंत्रित करने की अनुमति देता है, और थ्रेड्स के साथ कम मेमोरी और आरंभीकरण ओवरहेड भी है।

 fiber = Fiber.new do #    Fiber.yield "fiber 1" #     'fiber 2' #   end puts fiber.resume #   puts 'context' puts fiber.resume #    

कोड "फाइबर 1 संदर्भ फाइबर 2" का उत्पादन करेगा।



इसके लिए जीआईएल की जरूरत है:

 a = 0 threads = [] 10.times do #  10  threads << Thread.new do #      100000.times { a+= 1 } # 100 000 end end threads.each(&:join) #     puts a #   

कोड एमआरआई में 1,000,000 का उत्पादन करेगा, और नरक जानता है कि (100,000 से 1,000,000) रुबी और रूबिनियस में।

रूबी में धागे का उपयोग करना

MRI (Matz की रूबी दुभाषिया) इसके निर्माता युकीहिरो मात्सुमोतो की मुख्य रूबी शाखा है, या बस, Matz। सी। में लागू जब वे बस "रूबी" कहते हैं तो वे आम तौर पर इसका मतलब करते हैं। संस्करण 1.9 के साथ शुरू होकर परियोजना YARV (फिर भी एक और रूबी वीएम) के साथ विलय हो गया। इसकी मुख्य विशेषताओं में से एक तथाकथित GIL (ग्लोबल इंटरप्रेटर लॉक) है, उन्होंने इसके बारे में Habré ( निरंतरता के साथ ) पर लिखा था । रूबी 2.0 यूपीडी का वर्तमान संस्करण अब है: रूबी 2.1 जारी किया गया है । रूबी 2.1 से हम क्या उम्मीद कर सकते हैं?

jRuby , जो जावा में लिखा गया है और JVM में चलता है, और जावा कोड के अनुसार एकीकृत होता है। दुर्भाग्य से, भाषा संस्करण एमआरआई (रूबी 1.9.3 अब लागू हो गया है) से पिछड़ रहा है, लेकिन वही रेल इसके साथ आधा मोड़ से शुरू होती है।

रुबिनियस , जो एमआरआई पर आधारित है, लेकिन ऑपरेटिंग सिस्टम थ्रेड्स का उपयोग करता है, और रूबी के साथ अधिकतम संभव सीमा तक लिखा जाता है। संस्करण के अनुसार, आमतौर पर अप डेट करते हैं।

एक दूसरे के सापेक्ष सभी तीन कार्यान्वयन की गति कार्य से भिन्न होती है, और एक ट्रिनिटी से स्मृति की खपत के मामले में सबसे अधिक ग्लूटोनस है।

MacRuby - एलएलवीएम पर ऑब्जेक्टिव-सी के साथ मिलकर काम करता है, जो पहले के रूबिकोआ प्रोजेक्ट की जगह लेता है। IOS विकास के लिए, MacRuby - RubyMotion का एक कांटा है।

IronRuby एक .NET कार्यान्वयन है। जीवन भर, कभी-कभी इसे छोड़ दिया जाता है, फिर विकास फिर से शुरू होता है।

ओपल जावास्क्रिप्ट अनुवादक के लिए एक रूबी है। लेकिन उससे कुछ भी बकाया होने की उम्मीद न करें, यह Node.js के लिए jRuby नहीं है - यह सिर्फ रूबी में आपके jQuery कोड को लिखना संभव बनाता है। या कोड कोड के तहत Node.js. सामान्य तौर पर, कॉफीस्क्रिप्ट की थीम पर एक बदलाव।

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

आप MagLev का उल्लेख कर सकते हैं - एक विशिष्ट संस्करण, यह क्लाउड इंफ्रास्ट्रक्चर को तैनात करने के काम में आ सकता है।

इसके अलावा दिलचस्प मर्बी परियोजना है, जिसमें मात्ज़ भाग लेता है। यह एक एम्बेडेड रूबी है। परियोजना अभी समाप्त नहीं हुई है, लेकिन यह बहुत आशाजनक है। इसलिए, हम Arduino पर रूबी की प्रतीक्षा कर रहे हैं। मर्बी-आर्डिनो यह MobiRuby पर आधारित है, जिसे मोबाइल एप्लिकेशन विकसित करने के लिए डिज़ाइन किया गया है।

खैर, एक स्नैक के लिए, KidsRuby , पुराने लोगो की याद दिलाता है।