रूबी एक शुद्ध वस्तु-उन्मुख प्रोग्रामिंग भाषा है। इसे 1993 में जापान के युकीहिरो मात्सुमोतो द्वारा बनाया गया था।

आप रूबी मेलिंग सूची में युकीहिरो मात्सुमोतो का नाम www.ruby-lang.org पर पा सकते हैं । मात्सुमोतो को रूबी समुदाय में मात्ज़ के रूप में भी जाना जाता है।

Ruby is "A Programmer's Best Friend".

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

रूबी की विशेषताएं

• रूबी एक ओपन-सोर्स है और वेब पर स्वतंत्र रूप से उपलब्ध है, लेकिन यह एक लाइसेंस के अधीन है।

• रूबी एक सामान्य प्रयोजन, व्याख्या की गई प्रोग्रामिंग भाषा है।

• रूबी एक सच्ची वस्तु-उन्मुख प्रोग्रामिंग भाषा है।

• रूबी एक सर्वर-साइड स्क्रिप्टिंग भाषा है जो पायथन और पर्ल के समान है।

• रूबी का उपयोग कॉमन गेटवे इंटरफेस (CGI) स्क्रिप्ट लिखने के लिए किया जा सकता है।

• रूबी को हाइपरटेक्स्ट मार्कअप लैंग्वेज (HTML) में एम्बेड किया जा सकता है।

• रूबी के पास एक साफ और आसान वाक्यविन्यास है जो एक नए डेवलपर को बहुत जल्दी और आसानी से सीखने की अनुमति देता है।

• रूबी में कई प्रोग्रामिंग भाषाओं जैसे सी ++ और पर्ल के समान सिंटैक्स हैं।

• रूबी बहुत स्केलेबल है और रूबी में लिखे गए बड़े कार्यक्रम आसानी से बनाए रखने योग्य हैं।

• रूबी का उपयोग इंटरनेट और इंट्रानेट अनुप्रयोगों के विकास के लिए किया जा सकता है।

• रूबी को विंडोज और पोसिक्स वातावरण में स्थापित किया जा सकता है।

• रूबी कई GUI टूल्स जैसे Tcl / Tk, GTK और OpenGL का समर्थन करती है।

• रूबी को आसानी से DB2, MySQL, Oracle, और Sybase से जोड़ा जा सकता है।

• रूबी में अंतर्निहित कार्यों का एक समृद्ध सेट है, जिसका उपयोग सीधे रूबी लिपियों में किया जा सकता है।

उपकरण आप की आवश्यकता होगी

इस ट्यूटोरियल में चर्चित उदाहरणों के प्रदर्शन के लिए, आपको कम से कम 2GB RAM (4GB RAM अनुशंसित) के साथ Intel Core i3 या i5 जैसे नवीनतम कंप्यूटर की आवश्यकता होगी। आपको निम्न सॉफ्टवेयर की भी आवश्यकता होगी -

• लिनक्स या विंडोज 95/98/2000 / NT या विंडोज 7 ऑपरेटिंग सिस्टम।

• Apache 1.3.19-5 वेब सर्वर।

• इंटरनेट एक्सप्लोरर 5.0 या उससे ऊपर के वेब ब्राउज़र।

• रूबी 1.8.5

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

आगे क्या है?

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

स्थानीय पर्यावरण सेटअप

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

• लिनक्स / यूनिक्स पर रूबी इंस्टॉलेशन - यदि आप लिनक्स / यूनिक्स मशीन पर अपने विकास का वातावरण बनाने की योजना बना रहे हैं, तो इस अध्याय से गुजरें।

• विंडोज पर रूबी इंस्टॉलेशन - यदि आप विंडोज मशीन पर अपने विकास का माहौल बनाने की योजना बना रहे हैं, तो इस अध्याय से गुजरें।

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

• रूबी पर्यावरण चर - इस अध्याय में रूबी दुभाषिया काम करने के लिए निर्धारित किए जाने वाले सभी महत्वपूर्ण पर्यावरण चर की सूची है।

लोकप्रिय रूबी संपादक

अपने रूबी कार्यक्रमों को लिखने के लिए, आपको एक संपादक की आवश्यकता होगी -

• यदि आप विंडोज मशीन पर काम कर रहे हैं, तो आप नोटपैड या एडिट प्लस जैसे किसी भी साधारण टेक्स्ट एडिटर का उपयोग कर सकते हैं।

• VIM (Vi IMproved) एक बहुत ही सरल पाठ संपादक है। यह लगभग सभी यूनिक्स मशीनों और अब विंडोज पर भी उपलब्ध है। अन्यथा, आप रूबी कार्यक्रमों को लिखने के लिए अपने पसंदीदा vi संपादक का उपयोग कर सकते हैं।

• रूबिन विंडोज के लिए रूबी इंटीग्रेटेड डेवलपमेंट एनवायरनमेंट (IDE) है।

• रूबी डेवलपमेंट एनवायरनमेंट (RDE) भी विंडोज़ उपयोगकर्ताओं के लिए एक बहुत अच्छा आईडीई है।

इंटरएक्टिव रूबी (आईआरबी)

इंटरएक्टिव रूबी (आईआरबी) प्रयोग के लिए एक खोल प्रदान करता है। आईआरबी शेल के भीतर, आप तुरंत अभिव्यक्ति परिणाम, लाइन से लाइन देख सकते हैं।

यह उपकरण रूबी स्थापना के साथ आता है ताकि आपके पास आईआरबी काम करने के लिए अतिरिक्त कुछ भी न हो।

बस टाइप करो irb आपके कमांड प्रॉम्प्ट पर और नीचे दिए गए अनुसार इंटरएक्टिव रूबी सत्र शुरू होगा -

$irb
irb 0.6.1(99/09/16)
irb(main):001:0> def hello
irb(main):002:1> out = "Hello World"
irb(main):003:1> puts out
irb(main):004:1> end
nil
irb(main):005:0> hello
Hello World
nil
irb(main):006:0>

चिंता मत करो कि हमने यहां क्या किया। आप इन सभी चरणों को बाद के अध्यायों में जानेंगे।

आगे क्या है?

हमारा मानना ​​है कि अब आपके पास काम करने वाला रूबी पर्यावरण है और आप पहले रूबी प्रोग्राम लिखने के लिए तैयार हैं। अगला अध्याय आपको सिखाएगा कि रूबी प्रोग्राम कैसे लिखें।

आइए हम रूबी में एक सरल कार्यक्रम लिखें। सभी रूबी फ़ाइलों का विस्तार होगा.rb। तो, test.rb फ़ाइल में निम्न स्रोत कोड डालें।

#!/usr/bin/ruby -w

puts "Hello, Ruby!";

यहाँ, हमने मान लिया है कि आपके पास / usr / बिन निर्देशिका में रूबी दुभाषिया उपलब्ध है। अब, इस कार्यक्रम को इस प्रकार चलाने की कोशिश करें -

$ ruby test.rb

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Hello, Ruby!

आपने एक साधारण रूबी कार्यक्रम देखा है, अब हम रूबी सिंटैक्स से संबंधित कुछ बुनियादी अवधारणाओं को देखते हैं।

रूबी कार्यक्रम में व्हॉट्सएप

स्पेस और टैब जैसे व्हॉट्सएप के पात्रों को आमतौर पर रूबी कोड में नजरअंदाज किया जाता है, सिवाय इसके जब वे तार में दिखाई देते हैं। कभी-कभी, हालांकि, उनका उपयोग अस्पष्ट बयानों की व्याख्या करने के लिए किया जाता है। -W विकल्प सक्षम होने पर इस प्रकार की व्याख्या चेतावनी उत्पन्न करती है।

उदाहरण

a + b is interpreted as a+b ( Here a is a local variable)
a  +b is interpreted as a(+b) ( Here a is a method call)

रूबी कार्यक्रम में लाइन अंत

रूबी एक बयान की समाप्ति के रूप में अर्धविराम और न्यूलाइन वर्णों की व्याख्या करती है। हालांकि, अगर रूबी एक पंक्ति के अंत में ऑपरेटरों, जैसे +, - या बैकस्लैश का सामना करता है, तो वे एक बयान की निरंतरता का संकेत देते हैं।

रूबी पहचानकर्ता

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

रूबी पहचानकर्ता नामों में अल्फ़ान्यूमेरिक वर्ण और अंडरस्कोर वर्ण (_) शामिल हो सकते हैं।

सुरक्षित शब्द

निम्न सूची रूबी में आरक्षित शब्दों को दर्शाती है। इन आरक्षित शब्दों का उपयोग निरंतर या परिवर्तनशील नामों के रूप में नहीं किया जा सकता है। हालाँकि, उन्हें विधि नामों के रूप में उपयोग किया जा सकता है।

शुरू	कर	आगे	फिर
समाप्त	अन्य	शून्य	सच
उपनाम	elsif	नहीं	यूएनडीईएफ
तथा	समाप्त	या	जब तक
शुरू	सुनिश्चित	फिर से करें	जब तक
टूटना	असत्य	बचाव	कब
मामला	के लिये	पुन: प्रयास करें	जबकि
कक्षा	अगर	वापसी	जबकि
डीईएफ़	में	स्वयं	__FILE__
परिभाषित?	मापांक	उत्तम	__LINE__

यहाँ रूबी में दस्तावेज़

"यहाँ दस्तावेज़" कई लाइनों से तार बनाने के लिए संदर्भित करता है। << के बाद आप स्ट्रिंग शाब्दिक को समाप्त करने के लिए एक स्ट्रिंग या एक पहचानकर्ता निर्दिष्ट कर सकते हैं, और वर्तमान रेखा से टर्मिनेटर तक सभी लाइनें स्ट्रिंग का मान हैं।

यदि टर्मिनेटर उद्धृत किया जाता है, तो उद्धरण का प्रकार लाइन-ओरिएंटेड स्ट्रिंग शाब्दिक के प्रकार को निर्धारित करता है। ध्यान दें कि << और टर्मिनेटर के बीच कोई स्थान नहीं होना चाहिए।

यहाँ विभिन्न उदाहरण हैं -

#!/usr/bin/ruby -w

print <<EOF
   This is the first way of creating
   here document ie. multiple line string.
EOF

print <<"EOF";                # same as above
   This is the second way of creating
   here document ie. multiple line string.
EOF

print <<`EOC`                 # execute commands
	echo hi there
	echo lo there
EOC

print <<"foo", <<"bar"  # you can stack them
	I said foo.
foo
	I said bar.
bar

यह निम्नलिखित परिणाम का उत्पादन करेगा -

This is the first way of creating
   her document ie. multiple line string.
   This is the second way of creating
   her document ie. multiple line string.
hi there
lo there
      I said foo.
      I said bar.

रूबी BEGIN स्टेटमेंट

वाक्य - विन्यास

BEGIN {
   code
}

प्रोग्राम चलाने से पहले कोड को घोषित करने की घोषणा करता है।

उदाहरण

#!/usr/bin/ruby

puts "This is main Ruby Program"

BEGIN {
   puts "Initializing Ruby Program"
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Initializing Ruby Program
This is main Ruby Program

रूबी END कथन

वाक्य - विन्यास

END {
   code
}

कार्यक्रम के अंत में बुलाया जाने वाला कोड घोषित करता है।

उदाहरण

#!/usr/bin/ruby

puts "This is main Ruby Program"

END {
   puts "Terminating Ruby Program"
}
BEGIN {
   puts "Initializing Ruby Program"
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Initializing Ruby Program
This is main Ruby Program
Terminating Ruby Program

रूबी टिप्पणियाँ

एक टिप्पणी एक रेखा, एक रेखा का हिस्सा या रूबी दुभाषिया से कई पंक्तियों को छिपाती है। आप एक पंक्ति की शुरुआत में हैश चरित्र (#) का उपयोग कर सकते हैं -

# I am a comment. Just ignore me.

या, एक बयान या अभिव्यक्ति के बाद एक ही लाइन पर एक टिप्पणी हो सकती है -

name = "Madisetti" # This is again comment

आप कई पंक्तियों को निम्नानुसार टिप्पणी कर सकते हैं -

# This is a comment.
# This is a comment, too.
# This is a comment, too.
# I said that already.

यहाँ एक और रूप है। यह ब्लॉक कमेंट इंटरप्रेटर से कई लाइनों को = start / = end के साथ छुपाता है -

=begin
This is a comment.
This is a comment, too.
This is a comment, too.
I said that already.
=end

रूबी एक परफेक्ट ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग लैंग्वेज है। ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग भाषा की विशेषताओं में शामिल हैं -

• डेटा एनकैप्सुलेशन
• अमूर्त डेटा
• Polymorphism
• Inheritance

अध्याय ऑब्जेक्ट ओरिएंटेड रूबी में इन विशेषताओं पर चर्चा की गई है ।

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

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

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

एक वर्ग वाहन के रूप में परिभाषित किया जा सकता है -

Class Vehicle {

   Number no_of_wheels
   Number horsepower
   Characters type_of_tank
   Number Capacity
   Function speeding {
   }
   
   Function driving {
   }
   
   Function halting {
   }
}

इन डेटा सदस्यों को अलग-अलग मान देकर, आप क्लास वाहन के कई उदाहरण बना सकते हैं। उदाहरण के लिए, एक हवाई जहाज में तीन पहिये, 1,000 की अश्वशक्ति, टैंक के प्रकार के रूप में ईंधन और 100 लीटर की क्षमता होती है। उसी तरह, एक कार में चार पहिए, 200 की अश्वशक्ति, टैंक के प्रकार के रूप में गैस और 25 लीटर की क्षमता होती है।

रूबी में एक कक्षा को परिभाषित करना

रूबी का उपयोग करके ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग को लागू करने के लिए, आपको पहले सीखना होगा कि रूबी में ऑब्जेक्ट्स और क्लासेस कैसे बनाएं।

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

class Customer
end

आप कीवर्ड अंत का उपयोग करके एक वर्ग समाप्त करते हैं । कक्षा में सभी डेटा सदस्य वर्ग की परिभाषा और अंतिम कीवर्ड के बीच होते हैं ।

एक रूबी कक्षा में चर

रूबी चार प्रकार के चर प्रदान करती है -

• Local Variables- स्थानीय चर एक विधि में परिभाषित किए गए चर हैं। स्थानीय चर विधि के बाहर उपलब्ध नहीं हैं। आप बाद के अध्याय में विधि के बारे में अधिक जानकारी देखेंगे। स्थानीय चर लोअरकेस अक्षर या _ से शुरू होते हैं।

• Instance Variables- उदाहरण चर किसी भी विशेष उदाहरण या वस्तु के लिए तरीकों में उपलब्ध हैं। इसका मतलब है कि उदाहरण चर ऑब्जेक्ट से ऑब्जेक्ट में बदलते हैं। इंस्टेंस वैरिएबल के पहले चिन्ह (@) के बाद वेरिएबल नाम होता है।

• Class Variables- कक्षा चर विभिन्न वस्तुओं में उपलब्ध हैं। एक वर्ग चर वर्ग का है और एक वर्ग की विशेषता है। वे संकेत @ @ से पहले हैं और चर नाम से अनुसरण किए जाते हैं।

• Global Variables- कक्षा चर वर्ग भर में उपलब्ध नहीं हैं। यदि आप एक एकल चर रखना चाहते हैं, जो कक्षाओं में उपलब्ध है, तो आपको एक वैश्विक चर को परिभाषित करने की आवश्यकता है। वैश्विक चर हमेशा डॉलर चिन्ह ($) से पहले होते हैं।

उदाहरण

वर्ग चर @@ no_of_customers का उपयोग करके, आप बनाए जा रहे ऑब्जेक्ट की संख्या निर्धारित कर सकते हैं। यह ग्राहकों की संख्या प्राप्त करने में सक्षम बनाता है।

class Customer
   @@no_of_customers = 0
end

नई विधि का उपयोग करके रूबी में ऑब्जेक्ट बनाना

वस्तुएं वर्ग के उदाहरण हैं। अब आप सीखेंगे कि रूबी में एक वर्ग की वस्तुओं को कैसे बनाया जाए। आप कक्षा के नए तरीके का उपयोग करके रूबी में ऑब्जेक्ट बना सकते हैं ।

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

यहाँ दो वस्तुओं को बनाने के लिए एक उदाहरण है cust1 और 2 ग्राहक वर्ग का -

cust1 = Customer. new
cust2 = Customer. new

यहाँ, cust1 और cust2 दो वस्तुओं के नाम हैं। आप हस्ताक्षर के बाद (=) के बाद वाले ऑब्जेक्ट नाम को लिखते हैं जिसके बाद वर्ग नाम का अनुसरण करेगा। फिर, डॉट ऑपरेटर और कीवर्ड नया अनुसरण करेगा।

रूबी ऑब्जेक्ट बनाने के लिए कस्टम विधि

आप मापदंडों को नए तरीके से पास कर सकते हैं और उन मापदंडों का उपयोग वर्ग चर को आरंभ करने के लिए किया जा सकता है।

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

इनिशियलाइज़ विधि विधि एक विशेष प्रकार का है, जो जब निष्पादित किया जाएगा है नया वर्ग की विधि पैरामीटर के साथ कहा जाता है।

यहाँ आरंभिक विधि बनाने का उदाहरण दिया गया है -

class Customer
   @@no_of_customers = 0
   def initialize(id, name, addr)
      @cust_id = id
      @cust_name = name
      @cust_addr = addr
   end
end

इस उदाहरण में, आप के साथ आरंभिक विधि की घोषणा करते हैंid, name, तथा addrस्थानीय चर के रूप में। यहां, रूबी पद्धति को परिभाषित करने के लिए डीईएफ़ और एंड का उपयोग किया जाता है । आप बाद के अध्यायों में विधियों के बारे में अधिक जानेंगे।

में इनिशियलाइज़ विधि, आप उदाहरण चर के लिए इन स्थानीय चर का मान प्रदान करने वाली @cust_id, @cust_name, और @cust_addr। यहां स्थानीय चर उन मानों को रखते हैं जो नई विधि के साथ पारित किए जाते हैं।

अब, आप वस्तुओं को इस प्रकार बना सकते हैं -

cust1 = Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2 = Customer.new("2", "Poul", "New Empire road, Khandala")

रूबी क्लास में सदस्य कार्य

रूबी में, फ़ंक्शन को विधियों कहा जाता है। एक में प्रत्येक विधि वर्ग खोजशब्द के साथ शुरू होता है डीईएफ़ विधि नाम और उसके बाद।

विधि नाम हमेशा में पसंद किया जाता है lowercase letters। आप कीवर्ड अंत का उपयोग करके रूबी में एक विधि समाप्त करते हैं ।

रूबी विधि को परिभाषित करने के लिए यहाँ उदाहरण है -

class Sample
   def function
      statement 1
      statement 2
   end
end

यहां, स्टेटमेंट 1 और स्टेटमेंट 2 क्लास सैंपल के अंदर मेथड फंक्शन के बॉडी का हिस्सा हैं । ये मूर्तियाँ किसी भी मान्य रूबी कथन की हो सकती हैं। उदाहरण के लिए हम एक विधि डाल सकते हैं कहते हैं मुद्रित करने के लिए हैलो रूबी इस प्रकार -

class Sample
   def hello
      puts "Hello Ruby!"
   end
end

अब निम्नलिखित उदाहरण में, नमूना वर्ग की एक वस्तु बनाएं और हैलो विधि को कॉल करें और परिणाम देखें -

#!/usr/bin/ruby

class Sample
   def hello
      puts "Hello Ruby!"
   end
end

# Now using above class to create objects
object = Sample. new
object.hello

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Hello Ruby!

सिंपल केस स्टडी

यहाँ एक केस स्टडी है यदि आप क्लास और ऑब्जेक्ट्स के साथ अधिक अभ्यास करना चाहते हैं।

रूबी क्लास केस स्टडी

चर स्मृति स्थान हैं, जो किसी भी प्रोग्राम द्वारा उपयोग किए जाने वाले किसी भी डेटा को पकड़ते हैं।

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

रूबी ग्लोबल चर

वैश्विक चर $ के साथ शुरू होते हैं। Uninitialized वैश्विक वैरिएबल में शून्य मान होता है और -w विकल्प के साथ चेतावनी देता है।

वैश्विक चर के लिए असाइनमेंट वैश्विक स्थिति को बदल देता है। यह वैश्विक चर का उपयोग करने के लिए अनुशंसित नहीं है। वे कार्यक्रमों को गूढ़ बनाते हैं।

यहाँ एक उदाहरण है जो वैश्विक चर के उपयोग को दर्शाता है।

#!/usr/bin/ruby

$global_variable = 10 class Class1 def print_global puts "Global variable in Class1 is #$global_variable"
   end
end
class Class2
   def print_global
      puts "Global variable in Class2 is #$global_variable"
   end
end

class1obj = Class1.new
class1obj.print_global
class2obj = Class2.new
class2obj.print_global

यहाँ $ Global_variable एक वैश्विक चर है। यह निम्नलिखित परिणाम का उत्पादन करेगा -

NOTE - रूबी में, आप उस चर या स्थिर के ठीक पहले हैश (#) वर्ण लगाकर किसी भी चर या निरंतर के मूल्य का उपयोग कर सकते हैं।

Global variable in Class1 is 10
Global variable in Class2 is 10

रूबी इंस्टेंस वेरिएबल्स

इंस्टेंस चर @ के साथ शुरू होते हैं। Uninitialized इंस्टेंस वेरिएबल्स में वैल्यू nil होता है और -w ऑप्शन के साथ चेतावनियाँ उत्पन्न करता है।

यहाँ एक उदाहरण है उदाहरण Variables का उपयोग दिखा रहा है।

#!/usr/bin/ruby

class Customer
   def initialize(id, name, addr)
      @cust_id = id
      @cust_name = name
      @cust_addr = addr
   end
   def display_details()
      puts "Customer id #@cust_id"
      puts "Customer name #@cust_name"
      puts "Customer address #@cust_addr"
   end
end

# Create Objects
cust1 = Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2 = Customer.new("2", "Poul", "New Empire road, Khandala")

# Call Methods
cust1.display_details()
cust2.display_details()

यहाँ, @cust_id, @cust_name और @cust_addr उदाहरण चर हैं। यह निम्नलिखित परिणाम का उत्पादन करेगा -

Customer id 1
Customer name John
Customer address Wisdom Apartments, Ludhiya
Customer id 2
Customer name Poul
Customer address New Empire road, Khandala

रूबी वर्ग चर

वर्ग चर @@ के साथ शुरू होते हैं और उन्हें विधि परिभाषाओं में उपयोग किए जाने से पहले प्रारंभ किया जाना चाहिए।

एक uninitialized वर्ग चर को संदर्भित करने से एक त्रुटि उत्पन्न होती है। वर्ग चर वर्ग या मॉड्यूल के वंशज के बीच साझा किए जाते हैं जिसमें वर्ग चर परिभाषित किए जाते हैं।

ओवरराइडिंग क्लास वैरिएबल -w विकल्प के साथ चेतावनी उत्पन्न करते हैं।

यहाँ कक्षा चर के उपयोग को दर्शाने वाला एक उदाहरण है -

#!/usr/bin/ruby

class Customer
   @@no_of_customers = 0
   def initialize(id, name, addr)
      @cust_id = id
      @cust_name = name
      @cust_addr = addr
   end
   def display_details()
      puts "Customer id #@cust_id"
      puts "Customer name #@cust_name"
      puts "Customer address #@cust_addr"
   end
   def total_no_of_customers()
      @@no_of_customers += 1
      puts "Total number of customers: #@@no_of_customers"
   end
end

# Create Objects
cust1 = Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2 = Customer.new("2", "Poul", "New Empire road, Khandala")

# Call Methods
cust1.total_no_of_customers()
cust2.total_no_of_customers()

यहाँ @@ no_of_customers एक वर्ग चर है। यह निम्नलिखित परिणाम का उत्पादन करेगा -

Total number of customers: 1
Total number of customers: 2

रूबी स्थानीय चर

स्थानीय चर लोअरकेस अक्षर या _ से शुरू होते हैं। स्थानीय वैरिएबल का दायरा वर्ग, मॉड्यूल, डीईएफ, या संबंधित छोर तक या ब्लॉक के शुरुआती ब्रेस से उसके करीबी ब्रेस {} तक होता है।

जब एक अनधिकृत स्थानीय चर को संदर्भित किया जाता है, तो इसे एक विधि के रूप में कॉल किया जाता है जिसमें कोई तर्क नहीं है।

असिंचित स्थानीय चर के लिए असाइनमेंट भी चर घोषणा के रूप में कार्य करता है। मौजूदा दायरे के अंत तक पहुंचने के लिए चर मौजूद होने लगते हैं। स्थानीय चर का जीवनकाल तब निर्धारित किया जाता है जब रूबी कार्यक्रम को पूरा करती है।

उपरोक्त उदाहरण में, स्थानीय चर आईडी, नाम और एड्र हैं।

रूबी लगातार

स्थिरांक एक बड़े अक्षर से शुरू होते हैं। किसी वर्ग या मॉड्यूल के भीतर परिभाषित स्थिरांक को उस वर्ग या मॉड्यूल के भीतर से एक्सेस किया जा सकता है, और एक वर्ग या मॉड्यूल के बाहर परिभाषित किए गए लोगों को वैश्विक स्तर पर एक्सेस किया जा सकता है।

लगातार तरीकों के भीतर परिभाषित नहीं किया जा सकता है। अनइंस्टॉल किए गए निरंतर को संदर्भित करने से एक त्रुटि उत्पन्न होती है। एक स्थिरांक को असाइन करना जो पहले से ही इनिशियलाइज़ है, चेतावनी देता है।

#!/usr/bin/ruby

class Example
   VAR1 = 100
   VAR2 = 200
   def show
      puts "Value of first Constant is #{VAR1}"
      puts "Value of second Constant is #{VAR2}"
   end
end

# Create Objects
object = Example.new()
object.show

यहाँ VAR1 और VAR2 स्थिरांक हैं। यह निम्नलिखित परिणाम का उत्पादन करेगा -

Value of first Constant is 100
Value of second Constant is 200

रूबी स्यूडो-चर

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

• self - वर्तमान विधि का रिसीवर ऑब्जेक्ट।

• true - सच का प्रतिनिधित्व मूल्य।

• false - मूल्य झूठी का प्रतिनिधित्व करता है।

• nil - अपरिभाषित का प्रतिनिधित्व मूल्य।

• __FILE__ - वर्तमान स्रोत फ़ाइल का नाम।

• __LINE__ - सोर्स फाइल में करंट लाइन नंबर।

रूबी बुनियादी साहित्य

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

पूर्णांक संख्या

रूबी पूर्णांक संख्याओं का समर्थन करती है। एक पूर्णांक संख्या -2 ³⁰ से 2 ^30-1 या -2 ⁶² से 2 ^{62-1 तक हो सकती है} । इस सीमा के भीतर पूर्णांकों वर्ग की वस्तुओं रहे हैं Fixnum इस सीमा के बाहर और पूर्णांकों वर्ग की वस्तुओं में जमा हो जाती bignum ।

आप एक वैकल्पिक अग्रणी संकेत, एक वैकल्पिक आधार सूचक (ओक्टल के लिए 0, हेक्स के लिए 0 या बाइनरी के लिए 0 बी) का उपयोग करके पूर्णांक लिखते हैं, इसके बाद उचित आधार में अंकों की एक स्ट्रिंग होती है। अंक स्ट्रिंग में अंडरस्कोर वर्णों को अनदेखा किया जाता है।

आप ASCII वर्ण के अनुरूप पूर्णांक मान भी प्राप्त कर सकते हैं, या प्रश्नवाचक चिह्न के साथ पूर्ववर्ती अनुक्रम से बच सकते हैं।

उदाहरण

123                  # Fixnum decimal
1_234                # Fixnum decimal with underline
-500                 # Negative Fixnum
0377                 # octal
0xff                 # hexadecimal
0b1011               # binary
?a                   # character code for 'a'
?\n                  # code for a newline (0x0a)
12345678901234567890 # Bignum

NOTE - क्लास और ऑब्जेक्ट्स को इस ट्यूटोरियल के एक अलग अध्याय में समझाया गया है।

फ्लोटिंग नंबर

रूबी फ्लोटिंग नंबरों का समर्थन करती है। वे संख्या भी हैं, लेकिन दशमलव के साथ। फ्लोटिंग-पॉइंट नंबर क्लास फ्लोट की वस्तुएं हैं और इनमें से कोई भी हो सकती है -

उदाहरण

123.4                # floating point value
1.0e6                # scientific notation
4E20                 # dot not required
4e+20                # sign before exponential

स्ट्रिंग लिटरल

रूबी स्ट्रिंग्स केवल 8-बिट बाइट्स के अनुक्रम हैं और वे कक्षा स्ट्रिंग की वस्तुएं हैं। डबल-उद्धृत स्ट्रिंग्स प्रतिस्थापन और बैकस्लैश संकेतन की अनुमति देते हैं लेकिन एकल-उद्धृत स्ट्रिंग्स प्रतिस्थापन की अनुमति नहीं देते हैं और केवल \\ और \ के लिए बैकस्लैश नोटेशन की अनुमति देते हैं

उदाहरण

#!/usr/bin/ruby -w

puts 'escape using "\\"';
puts 'That\'s right';

यह निम्नलिखित परिणाम का उत्पादन करेगा -

escape using "\"
That's right

आप अनुक्रम का उपयोग करके किसी भी रूबी अभिव्यक्ति के मूल्य को एक स्ट्रिंग में स्थानापन्न कर सकते हैं #{ expr }। यहाँ, expr किसी भी रूबी अभिव्यक्ति हो सकती है।

#!/usr/bin/ruby -w

puts "Multiplication Value : #{24*60*60}";

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Multiplication Value : 86400

बैकस्लैश नोटेशन

रूबी द्वारा समर्थित बैकस्लैश नोटिफिकेशन की सूची निम्नलिखित है -

नोटेशन	चरित्र का प्रतिनिधित्व किया
\ n	न्यूलाइन (0x0a)
\ r	गाड़ी वापसी (0x0d)
\ च	फॉर्मफीड (0x0c)
\ b	बैकस्पेस (0x08)
\ए	बेल (0x07)
\इ	बच (0x1b)
\ रों	अंतरिक्ष (0x20)
\ NNN	अष्टक अंकन (n 4-7)
\ xnn	हेक्साडेसिमल नोटेशन (एन 0-9, एफएफ या एएफ)
\ cx, \ Cx	नियंत्रण एक्स
\ एमएक्स	मेटा-एक्स (सी। 0x80)
\ एम \ Cx	मेटा-नियंत्रण-x
\एक्स	चरित्र x

रूबी स्ट्रिंग्स पर अधिक विस्तार के लिए, रूबी स्ट्रिंग्स के माध्यम से जाएं ।

रूबी ऐरे

रूबी ऐरे के साहित्य को वर्ग कोष्ठक के बीच वस्तु संदर्भों की अल्पविराम से अलग श्रृंखला बनाकर बनाया जाता है। एक अनुगामी अल्पविराम की अनदेखी की जाती है।

उदाहरण

#!/usr/bin/ruby

ary = [  "fred", 10, 3.14, "This is a string", "last element", ]
ary.each do |i|
   puts i
end

यह निम्नलिखित परिणाम का उत्पादन करेगा -

fred
10
3.14
This is a string
last element

रूबी एरे पर अधिक विस्तार के लिए, रूबी एरे के माध्यम से जाएं ।

रूबी हैशिंग

एक शाब्दिक रूबी हैश को ब्रेसिज़ के बीच की / वैल्यू पेयर की लिस्ट रखकर बनाया जाता है, जिसमें की और वैल्यू के बीच कॉमा या सीक्वेंस => होता है। एक अनुगामी अल्पविराम की अनदेखी की जाती है।

उदाहरण

#!/usr/bin/ruby

hsh = colors = { "red" => 0xf00, "green" => 0x0f0, "blue" => 0x00f }
hsh.each do |key, value|
   print key, " is ", value, "\n"
end

यह निम्नलिखित परिणाम का उत्पादन करेगा -

red is 3840
green is 240
blue is 15

रूबी हैशिंग पर अधिक विस्तार के लिए, रूबी हैशिंग से गुजरें ।

रूबी रंग

एक रेंज एक अंतराल का प्रतिनिधित्व करती है जो कि एक शुरुआत और अंत के साथ मूल्यों का एक सेट है। रेंजों का निर्माण s..e और s ... e लिटरल या रेंज.न्यू के साथ किया जा सकता है।

रंग का उपयोग कर बनाया .. शुरू से अंत तक समावेशी रूप से चलाते हैं। जिनका उपयोग करके बनाया गया ... अंत मान को बाहर करें। जब इसे एक इटरेटर के रूप में उपयोग किया जाता है, तो रेंज प्रत्येक मान को अनुक्रम में वापस करती हैं।

एक श्रेणी (1..5) का अर्थ है कि इसमें 1, 2, 3, 4, 5 मान और एक श्रेणी (1 ... 5) शामिल है अर्थात इसमें 1, 2, 3, 4 मान शामिल हैं।

उदाहरण

#!/usr/bin/ruby

(10..15).each do |n| 
   print n, ' ' 
end

यह निम्नलिखित परिणाम का उत्पादन करेगा -

10 11 12 13 14 15

रूबी रेंज पर अधिक विस्तार के लिए, रूबी रेंज से गुजरें ।

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

प्रत्येक ऑपरेटर (+ - * /% ** | ^ << >> && ||) के लिए, संक्षिप्त रूप असाइनमेंट ऑपरेटर (+ = - = आदि) का एक संगत रूप है।

रूबी अंकगणित संचालक

चर को 10 मानिए और चर b को 20 मानिए, तब -

ऑपरेटर	विवरण	उदाहरण
+	परिवर्धन - ऑपरेटर के दोनों ओर मान जोड़ता है।	a + b 30 देगा
-	घटाव - बाएं हाथ के ऑपरेंड से दाहिने हाथ के ऑपरेंड को घटाते हैं।	a - b देगा -10
*	गुणन - ऑपरेटर के दोनों ओर मूल्यों को गुणा करता है।	a * b 200 देगा
/	डिवीजन - दाएं हाथ के ऑपरेंड द्वारा बाएं हाथ के ऑपरेशन को विभाजित किया जाता है।	b / a 2 देगा
%	मापांक - दाएं हाथ से बाएं हाथ के ऑपरेंड को बांटा जाता है और शेष को लौटाता है।	ब% ए वल 0 ट
**	घातांक - ऑपरेटरों पर घातांक (शक्ति) गणना करता है।	एक ** बी 10 को 20 शक्ति देगा

रूबी तुलना ऑपरेटर

चर को 10 मानिए और चर b को 20 मानिए, तब -

ऑपरेटर	विवरण	उदाहरण
==	जाँच करता है कि दो ऑपरेंड का मूल्य बराबर है या नहीं, यदि हाँ तो स्थिति सच हो जाती है।	(a == b) सत्य नहीं है।
! =	जाँच करता है कि दो ऑपरेंड का मान बराबर है या नहीं, यदि मान बराबर नहीं हैं तो स्थिति सत्य हो जाती है।	(a! = b) सत्य है।
>	जाँच करता है कि क्या बाएं संकार्य का मान दाहिने संचालक के मान से अधिक है, यदि हाँ, तो स्थिति सत्य हो जाती है।	(a> b) सत्य नहीं है।
<	यह जाँचता है कि क्या बाएं संकार्य का मान दाहिने संचालक के मान से कम है, यदि हाँ तो स्थिति सही है।	(a <b) सत्य है।
> =	जाँच करता है कि क्या बाएं ऑपरेंड का मूल्य सही ऑपरेंड के मूल्य से अधिक या बराबर है, यदि हाँ तो स्थिति सच हो जाती है।	(a> = b) सत्य नहीं है।
<=	जाँच करता है कि क्या बाएं ऑपरेंड का मूल्य सही ऑपरेंड के मूल्य से कम या बराबर है, यदि हाँ तो स्थिति सच हो जाती है।	(ए <= बी) सच है।
<=>	संयुक्त तुलना ऑपरेटर। रिटर्न 0 अगर पहला ऑपरेंड दूसरे के बराबर है, तो पहला ऑपरेंड दूसरे से ज्यादा और -1 अगर पहला ऑपरेंड दूसरे से कम है।	(ए <=> बी) रिटर्न -1।
===	केस स्टेटमेंट के क्लॉज के समय समानता का परीक्षण करने के लिए उपयोग किया जाता है ।	(1 ... 10) === 5 रिटर्न सही।
.eql?	यदि रिसीवर और तर्क में समान प्रकार और समान मान हैं, तो यह सही है।	1 == 1.0 रिटर्न सही है, लेकिन 1.eql? (1.0) गलत है।
बराबरी का?	सही है अगर रिसीवर और तर्क में एक ही ऑब्जेक्ट आईडी है।	aObj bObj का डुप्लिकेट है तो aObj == bObj सत्य है, a.equal? ​​bObj असत्य है, लेकिन a। असमान? aObj सत्य है।

रूबी असाइनमेंट ऑपरेटर्स

चर को 10 मानिए और चर b को 20 मानिए, तब -

ऑपरेटर	विवरण	उदाहरण
=	साधारण असाइनमेंट ऑपरेटर, राइट साइड ऑपरेंड्स से लेफ्ट साइड ऑपरेंड तक वैल्यूज असाइन करता है।	c = a + b a + b को c में मान देगा
+ =	जोड़ें और असाइनमेंट ऑपरेटर, बाएं ऑपरेटर के लिए सही ऑपरेंड जोड़ता है और बाएं ऑपरेंड को परिणाम असाइन करता है।	c + = a, c = c + a के बराबर है
- =	घटाना और असाइनमेंट ऑपरेटर, बाएं ऑपरेंड से दाएं ऑपरेंड को घटाता है और बाएं ऑपरेंड को परिणाम असाइन करता है।	c - = a, c = c - a के बराबर है
* =	गुणा और असाइनमेंट ऑपरेटर, बाएं ऑपरेंड के साथ दाएं ऑपरेंड को गुणा करता है और बाएं ऑपरेंड को परिणाम असाइन करता है।	c * = a a c = c * a के बराबर है
/ =	डिवाइड और असाइनमेंट ऑपरेटर, बाएं ऑपरेंड को दाएं ऑपरेंड के साथ विभाजित करता है और परिणाम को बाएं ऑपरेंड को असाइन करता है।	c / = a, c = c / a के बराबर है
% =	मापांक और असाइनमेंट ऑपरेटर, दो ऑपरेंड का उपयोग करके मापांक लेता है और परिणाम को बाएं ऑपरेंड में असाइन करता है।	c% = a, c = c% a के बराबर है
** =	घातांक और असाइनमेंट ऑपरेटर, ऑपरेटरों पर घातांक (शक्ति) गणना करता है और बाएं ऑपरेंड को मान प्रदान करता है।	c ** = a, c = c ** a के बराबर है

रूबी समानांतर समीकरण

रूबी भी चर के समानांतर असाइनमेंट का समर्थन करती है। यह कई चर को रूबी कोड की एक पंक्ति के साथ आरंभ करने में सक्षम बनाता है। उदाहरण के लिए -

a = 10
b = 20
c = 30

यह समानांतर असाइनमेंट का उपयोग करके अधिक तेज़ी से घोषित किया जा सकता है -

a, b, c = 10, 20, 30

दो चर में रखे गए मानों की अदला-बदली के लिए समानांतर असाइनमेंट भी उपयोगी है -

a, b = b, c

रूबी बिटवाइज ऑपरेटर्स

बिटवाइज़ ऑपरेटर बिट पर काम करता है और बिट ऑपरेशन द्वारा बिट करता है।

मान लें कि अगर a = 60; और बी = 13; अब द्विआधारी प्रारूप में वे निम्नानुसार होंगे -

a    =  0011 1100
 b    =  0000 1101
 ------------------
 a&b  =  0000 1100
 a|b  =  0011 1101
 a^b  =  0011 0001
 ~a   =  1100 0011

निम्न Bitwise ऑपरेटरों रूबी भाषा द्वारा समर्थित हैं।

ऑपरेटर	विवरण	उदाहरण
और	बाइनरी और ऑपरेटर परिणाम के लिए थोड़ा सा कॉपी करता है यदि यह दोनों ऑपरेंड में मौजूद है।	(a & b) 12 देगा, जो 0000 1100 है
|	बाइनरी या ऑपरेटर थोड़ा सा कॉपी करता है अगर यह किसी भी ऑपरेंड में मौजूद है।	(a | b) 61 देगा, जो 0011 1101 है
^	बाइनरी एक्सओआर ऑपरेटर बिट को कॉपी करता है अगर यह एक ऑपरेंड में सेट होता है लेकिन दोनों नहीं।	(ए ^ बी) 49 देगा, जो 0011 0001 है
~	बाइनरी ओन्स कंप्लीट ऑपरेटर, एकात्मक है और इसमें 'फ्लिपिंग' बिट्स का प्रभाव है।	(~ ए) -61 देगा, जो कि हस्ताक्षरित बाइनरी नंबर के कारण २ के पूरक रूप में ११०० ००११ है।
<<	बाइनरी लेफ्ट शिफ्ट ऑपरेटर। बाएं ऑपरेंड वैल्यू को दाएं ऑपरेंड द्वारा निर्दिष्ट बिट्स की संख्या से छोड़ दिया जाता है।	एक << 2 240 देगा, जो कि 1111 0000 है
>>	बाइनरी राइट शिफ्ट ऑपरेटर। बाएं ऑपरेंड वैल्यू को दाएं ऑपरेंड द्वारा निर्दिष्ट बिट्स की संख्या से दाएं स्थानांतरित किया जाता है।	>> >> 2 15 देगा, जो 0000 1111 है

रूबी लॉजिकल ऑपरेटर्स

रूबी भाषा द्वारा निम्नलिखित तार्किक ऑपरेटरों का समर्थन किया जाता है

मान लें चर एक 10 रखती है और चर ख 20 रखती है, तो -

ऑपरेटर	विवरण	उदाहरण
तथा	जिसे लॉजिकल एंड ऑपरेटर कहा जाता है। यदि दोनों ऑपरेंड सच हैं, तो स्थिति सच हो जाती है।	(a और b) सत्य है।
या	जिसे लॉजिकल या ऑपरेटर कहा जाता है। यदि दो संचालकों में से कोई भी गैर शून्य है, तो स्थिति सच हो जाती है।	(a या b) सत्य है।
&&	जिसे लॉजिकल एंड ऑपरेटर कहा जाता है। यदि दोनों ऑपरेंड नॉन जीरो हैं, तो स्थिति सच हो जाती है।	(a && b) सत्य है।
||	जिसे लॉजिकल या ऑपरेटर कहा जाता है। यदि दो संचालकों में से कोई भी गैर शून्य है, तो स्थिति सच हो जाती है।	(ए || बी) सच है
!	जिसे लॉजिकल नॉट ऑपरेटर कहा जाता है। उपयोग अपने ऑपरेंड की तार्किक स्थिति को उलट देता है। यदि कोई शर्त सही है, तो तार्किक संचालक गलत नहीं करेगा।	! (a && b) गलत है।
नहीं	जिसे लॉजिकल नॉट ऑपरेटर कहा जाता है। उपयोग अपने ऑपरेंड की तार्किक स्थिति को उलट देता है। यदि कोई शर्त सही है, तो तार्किक संचालक गलत नहीं करेगा।	नहीं (a && b) गलत है।

रूबी टर्नेरी संचालक

एक और ऑपरेटर है जिसे टर्नेरी ऑपरेटर कहा जाता है। यह पहले एक सच्चे या गलत मूल्य के लिए एक अभिव्यक्ति का मूल्यांकन करता है और फिर मूल्यांकन के परिणाम के आधार पर दो दिए गए कथनों में से एक को निष्पादित करता है। सशर्त ऑपरेटर का यह सिंटैक्स है -

ऑपरेटर	विवरण	उदाहरण
? :	सशर्त अभिव्यक्ति	अगर हालत सच है? तब X मान: अन्यथा Y मान

रूबी रेंज ऑपरेटर्स

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

रूबी में, ये अनुक्रम ".." और "..." रेंज ऑपरेटरों का उपयोग करके बनाए गए हैं। दो-डॉट फ़ॉर्म एक समावेशी श्रेणी बनाता है, जबकि तीन-डॉट फ़ॉर्म एक सीमा बनाता है जो निर्दिष्ट उच्च मान को बाहर करता है।

ऑपरेटर	विवरण	उदाहरण
..	समावेशी बिंदु से अंत तक समावेशी की एक सीमा बनाता है।	1..10 1 से 10 समावेशी की सीमा बनाता है।
...	प्रारंभ बिंदु से अंत बिंदु अनन्य तक की सीमा बनाता है।	1 ... 10 1 से 9 तक की सीमा बनाता है।

रूबी परिभाषित? ऑपरेटर्स

परिभाषित? एक विशेष ऑपरेटर है जो यह निर्धारित करने के लिए एक विधि कॉल का रूप लेता है कि क्या पारित अभिव्यक्ति परिभाषित है या नहीं। यदि यह अभिव्यक्ति परिभाषित नहीं है , तो यह अभिव्यक्ति का विवरण स्ट्रिंग या शून्य देता है।

परिभाषित के विभिन्न उपयोग हैं? ऑपरेटर

उपयोग 1

defined? variable # True if variable is initialized

For Example

foo = 42
defined? foo    # => "local-variable"
defined? $_     # => "global-variable"
defined? bar    # => nil (undefined)

उपयोग २

defined? method_call # True if a method is defined

For Example

defined? puts        # => "method"
defined? puts(bar)   # => nil (bar is not defined here)
defined? unpack      # => nil (not defined here)

उपयोग ३

# True if a method exists that can be called with super user
defined? super

For Example

defined? super     # => "super" (if it can be called)
defined? super     # => nil (if it cannot be)

उपयोग ४

defined? yield   # True if a code block has been passed

For Example

defined? yield    # => "yield" (if there is a block passed)
defined? yield    # => nil (if there is no block)

रूबी डॉट "।" और डबल कोलोन "::" ऑपरेटर्स

आप मॉड्यूल के नाम और एक अवधि के साथ इसके नाम से पहले एक मॉड्यूल विधि कहते हैं, और आप मॉड्यूल नाम और दो कॉलोन का उपयोग करके एक निरंतर का संदर्भ देते हैं।

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

Remember रूबी में, वर्गों और विधियों को स्थिरांक भी माना जा सकता है।

आपको बस उपसर्ग करने की आवश्यकता है :: एक अभिव्यक्ति के साथ Const_name जो उपयुक्त वर्ग या मॉड्यूल ऑब्जेक्ट लौटाता है।

यदि कोई उपसर्ग अभिव्यक्ति का उपयोग नहीं किया जाता है, तो मुख्य ऑब्जेक्ट क्लास डिफ़ॉल्ट रूप से उपयोग किया जाता है।

यहाँ दो उदाहरण हैं -

MR_COUNT = 0         # constant defined on main Object class
module Foo
   MR_COUNT = 0
   ::MR_COUNT = 1    # set global count to 1
   MR_COUNT = 2      # set local count to 2
end
puts MR_COUNT        # this is the global constant
puts Foo::MR_COUNT   # this is the local "Foo" constant

Second Example

CONST = ' out there'
class Inside_one
   CONST = proc {' in there'}
   def where_is_my_CONST
      ::CONST + ' inside one'
   end
end
class Inside_two
   CONST = ' inside two'
   def where_is_my_CONST
      CONST
   end
end
puts Inside_one.new.where_is_my_CONST
puts Inside_two.new.where_is_my_CONST
puts Object::CONST + Inside_two::CONST
puts Inside_two::CONST + CONST
puts Inside_one::CONST
puts Inside_one::CONST.call + Inside_two::CONST

रूबी संचालक पूर्ववर्ती

निम्न तालिका सभी ऑपरेटरों को उच्चतम वरीयता से सबसे कम तक सूचीबद्ध करती है।

तरीका	ऑपरेटर	विवरण
हाँ	::	लगातार संकल्प ऑपरेटर
हाँ	[] [] =	तत्व संदर्भ, तत्व सेट
हाँ	**	घातांक (शक्ति तक बढ़ाएं)
हाँ	! ~ + -	नहीं, पूरक, एकरी प्लस और माइनस (अंतिम दो के लिए विधि नाम + @ और - @) हैं
हाँ	* *%	गुणा, भाग और मोडुलो
हाँ	+ -	जोड़ और घटाव
हाँ	>> <<	दाएं और बाएं बिटवाइड शिफ्ट
हाँ	और	बिटवाइज़ 'और'
हाँ	^ |	बिटवाइज़ एक्सक्लूसिव `OR’ और रेगुलर `OR’
हाँ	<= <>> =	तुलना ऑपरेटरों
हाँ	<=> == ===! = = ~ ~! ~	समानता और पैटर्न मैच ऑपरेटरों (! =! ~ तरीकों के रूप में परिभाषित नहीं किया जा सकता है)
	&&	तार्किक 'और'
	||	तार्किक 'या'
	.. ...	रेंज (समावेशी और अनन्य)
	? :	टर्नरी अगर-तब-तब
	=% = {/ = - = + = | = & = >> = << = * = && = || = ** = = |	असाइनमेंट
	परिभाषित?	निर्दिष्ट प्रतीक की जाँच करें
	नहीं	तार्किक नकार
	या और	तार्किक रचना

NOTE- विधि कॉलम में हां के साथ ऑपरेटर वास्तव में विधियां हैं, और जैसे कि ओवरराइड हो सकता है।

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

#!/usr/bin/ruby -w
# This is a single line comment.

puts "Hello, Ruby!"

जब निष्पादित किया जाता है, तो उपरोक्त कार्यक्रम निम्नलिखित परिणाम उत्पन्न करता है -

Hello, Ruby!

रूबी मल्टीलाइन टिप्पणियाँ

आप कई लाइनों का उपयोग कर टिप्पणी कर सकते हैं =begin तथा =end सिंटैक्स निम्नानुसार है -

#!/usr/bin/ruby -w

puts "Hello, Ruby!"

=begin
This is a multiline comment and con spwan as many lines as you
like. But =begin and =end should come in the first line only. 
=end

जब निष्पादित किया जाता है, तो उपरोक्त कार्यक्रम निम्नलिखित परिणाम उत्पन्न करता है -

Hello, Ruby!

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

@counter      # keeps track times page has been hit
@siteCounter  # keeps track of times all pages have been hit

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

रूबी अगर ... और स्टेटमेंट

वाक्य - विन्यास

if conditional [then]
   code...
[elsif conditional [then]
   code...]...
[else
   code...]
end

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

कार्यान्वित कोड अगर सशर्त सच है। यदि सशर्त सत्य नहीं है, तो अन्य खंड में निर्दिष्ट कोड निष्पादित किया जाता है।

यदि अभिव्यक्ति के सशर्त को आरक्षित शब्द से कोड से अलग किया जाता है , तो एक नई पंक्ति, या अर्धविराम।

उदाहरण

#!/usr/bin/ruby

x = 1
if x > 2
   puts "x is greater than 2"
elsif x <= 2 and x!=0
   puts "x is 1"
else
   puts "I can't guess the number"
end

x is 1

अगर संशोधक रूबी

वाक्य - विन्यास

code if condition

कार्यान्वित कोड अगर सशर्त सच है।

उदाहरण

#!/usr/bin/ruby

$debug = 1
print "debug\n" if $debug

यह निम्नलिखित परिणाम का उत्पादन करेगा -

debug

रूबी जब तक बयान नहीं करती

वाक्य - विन्यास

unless conditional [then]
   code
[else
   code ]
end

यदि शर्त गलत है, तो कोड निष्पादित करता है। यदि सशर्त सही है, तो अन्य खंड में निर्दिष्ट कोड निष्पादित किया जाता है।

उदाहरण

#!/usr/bin/ruby

x = 1 
unless x>=2
   puts "x is less than 2"
 else
   puts "x is greater than 2"
end

यह निम्नलिखित परिणाम का उत्पादन करेगा -

x is less than 2

रूबी जब तक संशोधक नहीं

वाक्य - विन्यास

code unless conditional

यदि शर्त गलत है, तो कोड निष्पादित करता है।

उदाहरण

#!/usr/bin/ruby

$var =  1
print "1 -- Value is set\n" if $var print "2 -- Value is set\n" unless $var

$var = false print "3 -- Value is set\n" unless $var

यह निम्नलिखित परिणाम का उत्पादन करेगा -

1 -- Value is set
3 -- Value is set

रूबी केस स्टेटमेंट

वाक्य - विन्यास

case expression
[when expression [, expression ...] [then]
   code ]...
[else
   code ]
end

केस द्वारा निर्दिष्ट अभिव्यक्ति की तुलना करता है और जब === ऑपरेटर का उपयोग करके निर्दिष्ट होता है और उस क्लॉज से मेल खाने वाले कोड को निष्पादित करता है ।

अभिव्यक्ति जब खंड द्वारा निर्दिष्ट बाईं संकार्य के रूप में मूल्यांकन किया जाता है। यदि क्लॉस मैच नहीं करता है , तो केस अन्य क्लॉज़ के कोड को निष्पादित करता है ।

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

case expr0
when expr1, expr2
   stmt1
when expr3, expr4
   stmt2
else
   stmt3
end

मूल रूप से निम्नलिखित के समान है -

_tmp = expr0
if expr1 === _tmp || expr2 === _tmp
   stmt1
elsif expr3 === _tmp || expr4 === _tmp
   stmt2
else
   stmt3
end

उदाहरण

#!/usr/bin/ruby

$age = 5 case $age
when 0 .. 2
   puts "baby"
when 3 .. 6
   puts "little child"
when 7 .. 12
   puts "child"
when 13 .. 18
   puts "youth"
else
   puts "adult"
end

यह निम्नलिखित परिणाम का उत्पादन करेगा -

little child

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

रूबी स्टेटमेंट करते हुए

वाक्य - विन्यास

while conditional [do]
   code
end

कोड निष्पादित करता है जबकि सशर्त सत्य है। एक जबकि पाश की सशर्त से अलग किया जाता कोड आरक्षित शब्द करते हैं, एक नई पंक्ति, बैकस्लैश \, या अर्धविराम द्वारा;।

उदाहरण

#!/usr/bin/ruby

$i = 0
$num = 5

while $i < $num  do
   puts("Inside the loop i = #$i" )
   $i +=1
end

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4

संशोधन करते समय रूबी

वाक्य - विन्यास

code while condition

OR

begin 
  code 
end while conditional

कोड निष्पादित करता है जबकि सशर्त सत्य है।

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

उदाहरण

#!/usr/bin/ruby

$i = 0
$num = 5
begin
   puts("Inside the loop i = #$i" )
   $i +=1
end while $i < $num

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4

रूबी स्टेटमेंट तक

until conditional [do]
   code
end

कोड निष्पादित करता है जबकि सशर्त गलत है। एक जब तक बयान की सशर्त से अलग किया जाता कोड आरक्षित शब्द से करते हैं , एक नई पंक्ति, या अर्धविराम।

उदाहरण

#!/usr/bin/ruby

$i = 0
$num = 5

until $i > $num  do
   puts("Inside the loop i = #$i" )
   $i +=1;
end

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4
Inside the loop i = 5

जब तक संशोधक रूबी

वाक्य - विन्यास

code until conditional

OR

begin
   code
end until conditional

कोड निष्पादित करता है जबकि सशर्त गलत है।

एक तो जब तक संशोधक का पालन करने वाले शुरू नहीं के साथ बयान बचाव या खंड सुनिश्चित करने, कोड से पहले एक बार निष्पादित किया जाता है सशर्त मूल्यांकन किया जाता है।

उदाहरण

#!/usr/bin/ruby

$i = 0
$num = 5
begin
   puts("Inside the loop i = #$i" )
   $i +=1;
end until $i > $num

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4
Inside the loop i = 5

रूबी स्टेटमेंट के लिए

वाक्य - विन्यास

for variable [, variable ...] in expression [do]
   code
end

अभिव्यक्ति में प्रत्येक तत्व के लिए एक बार कोड निष्पादित करता है ।

उदाहरण

#!/usr/bin/ruby

for i in 0..5
   puts "Value of local variable is #{i}"
end

यहां, हमने 0..5 श्रेणी को परिभाषित किया है। के लिए बयान मैं 0..5 में अनुमति देगा मैं (5 सहित) 0 से 5 तक की सीमा में मूल्यों लेने के लिए। यह निम्नलिखित परिणाम का उत्पादन करेगा -

Value of local variable is 0
Value of local variable is 1
Value of local variable is 2
Value of local variable is 3
Value of local variable is 4
Value of local variable is 5

एक के लिए ... पाश में लगभग निम्नलिखित के बराबर है -

(expression).each do |variable[, variable...]| code end

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

उदाहरण

#!/usr/bin/ruby

(0..5).each do |i|
   puts "Value of local variable is #{i}"
end

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Value of local variable is 0
Value of local variable is 1
Value of local variable is 2
Value of local variable is 3
Value of local variable is 4
Value of local variable is 5

रूबी ब्रेक स्टेटमेंट

वाक्य - विन्यास

break

सबसे आंतरिक लूप को समाप्त करता है। एक संबंधित ब्लॉक के साथ एक विधि को रोकता है यदि ब्लॉक के भीतर कहा जाता है (विधि के साथ वापस लौटना)।

उदाहरण

#!/usr/bin/ruby

for i in 0..5
   if i > 2 then
      break
   end
   puts "Value of local variable is #{i}"
end

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Value of local variable is 0
Value of local variable is 1
Value of local variable is 2

रूबी नेक्स्ट स्टेटमेंट

वाक्य - विन्यास

next

सबसे आंतरिक लूप के अगले पुनरावृत्ति के लिए कूदता है। यदि किसी ब्लॉक के भीतर ( उपज या कॉलिंग निल के साथ) कॉल किया जाता है, तो एक ब्लॉक के निष्पादन को समाप्त करता है ।

उदाहरण

#!/usr/bin/ruby

for i in 0..5
   if i < 2 then
      next
   end
   puts "Value of local variable is #{i}"
end

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Value of local variable is 2
Value of local variable is 3
Value of local variable is 4
Value of local variable is 5

रूबी फिर से बयान

वाक्य - विन्यास

redo

लूप स्थिति की जांच के बिना, सबसे आंतरिक लूप के इस पुनरावृत्ति को रोकता है। पुनरारंभ उपज या कॉल करता है, तो एक ब्लॉक के भीतर बुलाया।

उदाहरण

#!/usr/bin/ruby

for i in 0..5
   if i < 2 then
      puts "Value of local variable is #{i}"
      redo
   end
end

यह निम्नलिखित परिणाम देगा और एक अनंत लूप में जाएगा -

Value of local variable is 0
Value of local variable is 0
............................

रूबी रिट्रीमेंट स्टेटमेंट

वाक्य - विन्यास

retry

तो फिर से प्रयास करें की शुरुआत से अभिव्यक्ति, पुनः आरंभ करने के लिए शुरू के बचाव खंड में प्रकट होता है शरीर शुरू करते हैं।

begin
   do_something # exception raised
rescue
   # handles error
   retry  # restart from beginning
end

यदि पुनरावृत्ति पुनरावृत्ति में दिखाई देता है, तो ब्लॉक, या अभिव्यक्ति के लिए निकाय , पुनरावृत्ति को पुन: प्रारंभ करता है। पुनरावृत्ति करने वाले को पुनर्मूल्यांकन किया जाता है।

for i in 1..5
   retry if some_condition # restart from i == 1
end

उदाहरण

#!/usr/bin/ruby
for i in 0..5
   retry if i > 2
puts "Value of local variable is #{i}"
end

यह निम्नलिखित परिणाम देगा और एक अनंत लूप में जाएगा -

Value of local variable is 1
Value of local variable is 2
Value of local variable is 1
Value of local variable is 2
Value of local variable is 1
Value of local variable is 2
............................

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

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

उन्हें फोन करने से पहले तरीकों को परिभाषित किया जाना चाहिए, अन्यथा रूबी अपरिभाषित विधि के लिए एक अपवाद बढ़ाएगा।

वाक्य - विन्यास

def method_name [( [arg [= default]]...[, * arg [, &expr ]])]
   expr..
end

तो, आप एक सरल विधि को निम्नानुसार परिभाषित कर सकते हैं -

def method_name 
   expr..
end

आप एक ऐसी विधि का प्रतिनिधित्व कर सकते हैं जो इस तरह के मापदंडों को स्वीकार करती है -

def method_name (var1, var2)
   expr..
end

आप मापदंडों के लिए डिफ़ॉल्ट मान सेट कर सकते हैं, जिसका उपयोग यदि आवश्यक मापदंडों को पारित किए बिना विधि कहा जाता है -

def method_name (var1 = value1, var2 = value2)
   expr..
end

जब भी आप सरल विधि कहते हैं, आप केवल विधि का नाम इस प्रकार लिखते हैं -

method_name

हालाँकि, जब आप किसी विधि को पैरामीटर के साथ कहते हैं, तो आप पैरामीटर के साथ विधि का नाम लिखते हैं, जैसे कि -

method_name 25, 30

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

उदाहरण

#!/usr/bin/ruby

def test(a1 = "Ruby", a2 = "Perl")
   puts "The programming language is #{a1}"
   puts "The programming language is #{a2}"
end
test "C", "C++"
test

यह निम्नलिखित परिणाम का उत्पादन करेगा -

The programming language is C
The programming language is C++
The programming language is Ruby
The programming language is Perl

विधियों से मान लौटाएँ

रूबी में प्रत्येक विधि डिफ़ॉल्ट रूप से एक मान लौटाती है। यह लौटाया गया मान अंतिम विवरण का मान होगा। उदाहरण के लिए -

def test
   i = 100
   j = 10
   k = 0
end

यह विधि, जब बुलाया जाता है, तो अंतिम घोषित चर k वापस आ जाएगा ।

रूबी का बयान

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

वाक्य - विन्यास

return [expr[`,' expr...]]

यदि दो से अधिक अभिव्यक्तियाँ दी गई हैं, तो इन मानों वाले सरणी का रिटर्न मान होगा। यदि कोई अभिव्यक्ति नहीं दी गई है, तो एनआईएल रिटर्न मूल्य होगा।

उदाहरण

return

OR

return 12

OR

return 1,2,3

इस उदाहरण पर एक नजर -

#!/usr/bin/ruby

def test
   i = 100
   j = 200
   k = 300
return i, j, k
end
var = test
puts var

यह निम्नलिखित परिणाम का उत्पादन करेगा -

100
200
300

पैरामीटर्स की परिवर्तनीय संख्या

मान लीजिए कि आप एक ऐसी विधि की घोषणा करते हैं जो दो मापदंडों को लेती है, जब भी आप इस पद्धति को कहते हैं, तो आपको इसके साथ दो मापदंडों को पारित करने की आवश्यकता होती है।

हालांकि, रूबी आपको उन तरीकों की घोषणा करने की अनुमति देता है जो मापदंडों की एक चर संख्या के साथ काम करते हैं। आइए हम इसका एक नमूना देखें -

#!/usr/bin/ruby

def sample (*test)
   puts "The number of parameters is #{test.length}"
   for i in 0...test.length
      puts "The parameters are #{test[i]}"
   end
end
sample "Zara", "6", "F"
sample "Mac", "36", "M", "MCA"

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

The number of parameters is 3
The parameters are Zara
The parameters are 6
The parameters are F
The number of parameters is 4
The parameters are Mac
The parameters are 36
The parameters are M
The parameters are MCA

कक्षा के तरीके

जब एक विधि को वर्ग परिभाषा के बाहर परिभाषित किया जाता है, तो विधि को डिफ़ॉल्ट रूप से निजी के रूप में चिह्नित किया जाता है। दूसरी ओर, वर्ग परिभाषा में परिभाषित तरीकों को डिफ़ॉल्ट रूप से सार्वजनिक रूप से चिह्नित किया जाता है। डिफ़ॉल्ट दृश्यता और विधियों के निजी चिह्न को सार्वजनिक या निजी मॉड्यूल द्वारा बदला जा सकता है ।

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

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

class Accounts
   def reading_charge
   end
   def Accounts.return_date
   end
end

देखें कि कैसे विधि return_date घोषित की गई है। इसे वर्ग नाम के साथ एक अवधि के बाद घोषित किया जाता है, जिसके बाद विधि का नाम आता है। आप इस वर्ग विधि को सीधे इस प्रकार एक्सेस कर सकते हैं -

Accounts.return_date

इस पद्धति का उपयोग करने के लिए, आपको वर्ग खातों की वस्तुओं को बनाने की आवश्यकता नहीं है।

रूबी उर्फ़ बयान

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

गिने हुए वैश्विक चरों के लिए उपनाम बनाना ($ 1, $ 2, ...) निषिद्ध है। अंतर्निहित वैश्विक चर को ओवरराइड करने से गंभीर समस्याएं हो सकती हैं।

वाक्य - विन्यास

alias method-name method-name
alias global-variable-name global-variable-name

उदाहरण

alias foo bar
alias $MATCH $&

यहाँ हमने बार के लिए फू उर्फ ​​को परिभाषित किया है, और $ MATCH $ के लिए एक उपनाम है

रूबी अपराजित कथन

यह विधि परिभाषा को रद्द करता है। एक अनिर्दिष्ट विधि शरीर में प्रकट नहीं हो सकती।

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

वाक्य - विन्यास

undef method-name

उदाहरण

एक विधि को अपरिभाषित करने के लिए, जिसे बार कहा जाता है, निम्नलिखित करें -

undef bar

आपने देखा है कि रूबी उन तरीकों को कैसे परिभाषित करती है, जहां आप कई तरह के बयान दे सकते हैं और फिर आप उस पद्धति को कॉल कर सकते हैं। इसी तरह, रूबी के पास ब्लॉक की अवधारणा है।

• एक ब्लॉक में कोड का हिस्सा होता है।

• आप किसी ब्लॉक को नाम असाइन करते हैं।

• ब्लॉक में कोड हमेशा ब्रेसिज़ ({}) के भीतर संलग्न होता है।

• एक ब्लॉक को हमेशा एक फ़ंक्शन से ब्लॉक के समान नाम के साथ लागू किया जाता है। इसका मतलब है कि यदि आपके पास नाम परीक्षण के साथ ब्लॉक है , तो आप इस ब्लॉक को लागू करने के लिए फ़ंक्शन परीक्षण का उपयोग करते हैं ।

• आप उपज विवरण का उपयोग करके एक ब्लॉक का आह्वान करते हैं।

वाक्य - विन्यास

block_name {
   statement1
   statement2
   ..........
}

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

उपज कथन

आइए उपज कथन का एक उदाहरण देखें -

#!/usr/bin/ruby

def test
   puts "You are in the method"
   yield
   puts "You are again back to the method"
   yield
end
test {puts "You are in the block"}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

You are in the method
You are in the block
You are again back to the method
You are in the block

आप पैदावार स्टेटमेंट के साथ पैरामीटर भी पास कर सकते हैं। यहाँ एक उदाहरण है -

#!/usr/bin/ruby

def test
   yield 5
   puts "You are in the method test"
   yield 100
end
test {|i| puts "You are in the block #{i}"}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

You are in the block 5
You are in the method test
You are in the block 100

यहाँ, पैदावार विवरण को मापदंडों के बाद लिखा जाता है। आप एक से अधिक पैरामीटर भी पास कर सकते हैं। ब्लॉक में, आप मापदंडों को स्वीकार करने के लिए दो ऊर्ध्वाधर लाइनों (||) के बीच एक चर रखते हैं। इसलिए, पूर्ववर्ती कोड में, उपज 5 स्टेटमेंट 5 मान को टेस्ट ब्लॉक में पैरामीटर के रूप में पास करता है।

अब, निम्नलिखित कथन को देखें -

test {|i| puts "You are in the block #{i}"}

यहाँ, वैरिएबल I में मान 5 प्राप्त होता है । अब, निरीक्षण निम्नलिखित पुट बयान -

puts "You are in the block #{i}"

इस पुट स्टेटमेंट का आउटपुट है -

You are in the block 5

यदि आप एक से अधिक पैरामीटर पास करना चाहते हैं, तो उपज स्टेटमेंट बन जाता है -

yield a, b

और ब्लॉक है -

test {|a, b| statement}

मापदंडों को अल्पविराम से अलग किया जाएगा।

ब्लॉक और तरीके

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

#!/usr/bin/ruby

def test
   yield
end
test{ puts "Hello world"}

यह उदाहरण ब्लॉक को लागू करने का सबसे सरल तरीका है। आप उपज कथन का उपयोग करके परीक्षण ब्लॉक को कॉल करते हैं ।

लेकिन अगर किसी विधि का अंतिम तर्क पहले और उसके बाद आता है, तो आप इस विधि को एक ब्लॉक पास कर सकते हैं और यह ब्लॉक अंतिम पैरामीटर को सौंपा जाएगा। यदि दोनों * और / और तर्क सूची में मौजूद हैं, और बाद में आना चाहिए।

#!/usr/bin/ruby

def test(&block)
   block.call
end
test { puts "Hello World!"}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Hello World!

BEGIN और END ब्लॉक

प्रत्येक रूबी स्रोत फ़ाइल कोड के ब्लॉक को चलाने की घोषणा कर सकती है क्योंकि फ़ाइल लोड की जा रही है (BEGIN ब्लॉक) और प्रोग्राम के समाप्त होने के बाद (END ब्लॉक) निष्पादित किया जा रहा है।

#!/usr/bin/ruby

BEGIN { 
   # BEGIN block code 
   puts "BEGIN code block"
} 

END { 
   # END block code 
   puts "END code block"
}
   # MAIN block code 
puts "MAIN code block"

एक प्रोग्राम में कई BEGIN और END ब्लॉक शामिल हो सकते हैं। BEGIN ब्लॉकों को उनके सामने आने वाले क्रम में निष्पादित किया जाता है। END ब्लॉक रिवर्स ऑर्डर में निष्पादित किए जाते हैं। जब निष्पादित किया जाता है, तो उपरोक्त कार्यक्रम निम्नलिखित परिणाम उत्पन्न करता है -

BEGIN code block
MAIN code block
END code block

मॉड्यूल एक साथ तरीकों, वर्गों और स्थिरांक को समूहीकृत करने का एक तरीका है। मॉड्यूल आपको दो प्रमुख लाभ देते हैं।

• मॉड्यूल एक नाम स्थान प्रदान करते हैं और नाम संघर्ष को रोकते हैं।

• मॉड्यूल को लागू mixin सुविधा।

मॉड्यूल एक नाम स्थान, एक सैंडबॉक्स को परिभाषित करते हैं जिसमें आपके तरीके और स्थिरांक अन्य तरीकों और स्थिरांक द्वारा आगे बढ़ने के बारे में चिंता किए बिना खेल सकते हैं।

वाक्य - विन्यास

module Identifier
   statement1
   statement2
   ...........
end

प्रारंभिक स्थिरांक पत्र के साथ, मॉड्यूल स्थिरांक को बस स्थिरांक की तरह नाम दिया गया है। विधि परिभाषाएं समान दिखती हैं, भी: मॉड्यूल विधियां कक्षा के तरीकों की तरह ही परिभाषित की जाती हैं।

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

उदाहरण

#!/usr/bin/ruby

# Module defined in trig.rb file

module Trig
   PI = 3.141592654
   def Trig.sin(x)
   # ..
   end
   def Trig.cos(x)
   # ..
   end
end

हम एक ही फ़ंक्शन नाम के साथ एक और मॉड्यूल को परिभाषित कर सकते हैं लेकिन अलग कार्यक्षमता -

#!/usr/bin/ruby

# Module defined in moral.rb file

module Moral
   VERY_BAD = 0
   BAD = 1
   def Moral.sin(badness)
   # ...
   end
end

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

रूबी को स्टेटमेंट की आवश्यकता है

आवश्यकता कथन C और C ++ के कथन और जावा के आयात कथन के समान है। यदि कोई तीसरा प्रोग्राम किसी भी परिभाषित मॉड्यूल का उपयोग करना चाहता है, तो वह केवल रूबी आवश्यकता वाले स्टेटमेंट का उपयोग करके मॉड्यूल फ़ाइलों को लोड कर सकता है -

वाक्य - विन्यास

require filename

यहाँ, यह देने की आवश्यकता नहीं है .rb फ़ाइल नाम के साथ एक्सटेंशन।

उदाहरण

$LOAD_PATH << '.'

require 'trig.rb'
require 'moral'

y = Trig.sin(Trig::PI/4)
wrongdoing = Moral.sin(Moral::VERY_BAD)

यहां हम उपयोग कर रहे हैं $LOAD_PATH << '.'रूबी को जागरूक करने के लिए कि वर्तमान निर्देशिका में फ़ाइलें शामिल की जानी चाहिए। यदि आप $ LOAD_PATH का उपयोग नहीं करना चाहते हैं तो आप उपयोग कर सकते हैंrequire_relative एक रिश्तेदार निर्देशिका से फ़ाइलें शामिल करने के लिए।

IMPORTANT- यहां, दोनों फाइलों में समान फ़ंक्शन नाम है। इसलिए, यह कॉल प्रोग्राम में शामिल करते हुए कोड अस्पष्टता का परिणाम देगा लेकिन मॉड्यूल इस कोड अस्पष्टता से बचते हैं और हम मॉड्यूल नाम का उपयोग करके उपयुक्त फ़ंक्शन को कॉल करने में सक्षम हैं।

रूबी में स्टेटमेंट शामिल है

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

वाक्य - विन्यास

include modulename

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

उदाहरण

Support.rb फ़ाइल में लिखे गए निम्न मॉड्यूल पर विचार करें ।

module Week
   FIRST_DAY = "Sunday"
   def Week.weeks_in_month
      puts "You have four weeks in a month"
   end
   def Week.weeks_in_year
      puts "You have 52 weeks in a year"
   end
end

अब, आप इस मॉड्यूल को एक वर्ग में शामिल कर सकते हैं -

#!/usr/bin/ruby
$LOAD_PATH << '.'
require "support"

class Decade
include Week
   no_of_yrs = 10
   def no_of_months
      puts Week::FIRST_DAY
      number = 10*12
      puts number
   end
end
d1 = Decade.new
puts Week::FIRST_DAY
Week.weeks_in_month
Week.weeks_in_year
d1.no_of_months

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Sunday
You have four weeks in a month
You have 52 weeks in a year
Sunday
120

रूबी में मिक्स

इस खंड के माध्यम से जाने से पहले, हम मानते हैं कि आपको ऑब्जेक्ट ओरिएंटेड अवधारणाओं का ज्ञान है।

जब एक वर्ग एक से अधिक अभिभावकों की श्रेणी से सुविधाएँ प्राप्त कर सकता है, तो कक्षा को कई उत्तराधिकार दिखाने होंगे।

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

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

आइए हम मिश्रण के बारे में समझने के लिए निम्नलिखित नमूना कोड की जांच करें -

module A
   def a1
   end
   def a2
   end
end
module B
   def b1
   end
   def b2
   end
end

class Sample
include A
include B
   def s1
   end
end

samp = Sample.new
samp.a1
samp.a2
samp.b1
samp.b2
samp.s1

मॉड्यूल A में a1 और a2 विधियां शामिल हैं। मॉड्यूल बी में तरीकों बी 1 और बी 2 शामिल हैं। क्लास सैंपल में ए और बी दोनों मॉड्यूल शामिल हैं। क्लास सैंपल सभी चार तरीकों, अर्थात्, ए 1, ए 2, बी 1 और बी 2 तक पहुंच सकता है। इसलिए, आप देख सकते हैं कि वर्ग नमूना दोनों मॉड्यूल से विरासत में मिला है। इस प्रकार, आप वर्ग नमूना दिखाता है एकाधिक वंशानुक्रम या कह सकते हैं mixin ।

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

सबसे सरल स्ट्रिंग शाब्दिक एकल उद्धरण (एपोस्ट्रोफ चरित्र) में संलग्न हैं। उद्धरण चिह्नों के भीतर का पाठ स्ट्रिंग का मूल्य है -

'This is a simple Ruby string literal'

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

'Won\'t you read O\'Reilly\'s book?'

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

रूबी की स्ट्रिंग-संबंधी विशेषताएं निम्नलिखित हैं।

अभिव्यक्ति प्रतिस्थापन

अभिव्यक्ति प्रतिस्थापन # {और} का उपयोग करके स्ट्रिंग में किसी भी रूबी अभिव्यक्ति के मूल्य को एम्बेड करने का एक साधन है -

#!/usr/bin/ruby

x, y, z = 12, 36, 72
puts "The value of x is #{ x }."
puts "The sum of x and y is #{ x + y }."
puts "The average was #{ (x + y + z)/3 }."

यह निम्नलिखित परिणाम का उत्पादन करेगा -

The value of x is 12.
The sum of x and y is 48.
The average was 40.

सामान्य सीमांकित स्ट्रिंग्स

सामान्य सीमांकित स्ट्रिंग्स के साथ, आप मिलान के एक जोड़े के अंदर स्ट्रिंग्स बना सकते हैं, हालांकि मनमाने ढंग से सीमांकन के पात्र, जैसे ?, (,, {, <, आदि), एक प्रतिशत चरित्र (%) से पहले, क्यू, क्यू, और एक्स में विशेष अनुरेखण हैं। सामान्य सीमांकित तार हो सकते हैं -

%{Ruby is fun.}  equivalent to "Ruby is fun."
%Q{ Ruby is fun. } equivalent to " Ruby is fun. "
%q[Ruby is fun.]  equivalent to a single-quoted string
%x!ls! equivalent to back tick command output `ls`

वर्ण से बचो

निम्नलिखित तालिका भागने या गैर-मुद्रण योग्य वर्णों की एक सूची है जिसे बैकलैश नोटेशन के साथ दर्शाया जा सकता है।

NOTE- एक डबल-उद्धृत स्ट्रिंग में, एक एस्केप चरित्र व्याख्या की गई है; एकल-उद्धृत स्ट्रिंग में, एक एस्केप चरित्र संरक्षित है।

बैकस्लैश नोटेशन	षोडश चरित्र	विवरण
\ए	0x07	बेल या सतर्क
\ b	0x08	बैकस्पेस
\ cx		नियंत्रण एक्स
\ Cx		नियंत्रण एक्स
\इ	0x1b	पलायन
\ च	0x0c	फ़ीड बनाएं
\ एम \ Cx		मेटा-नियंत्रण-x
\ n	0x0A	नई पंक्ति
\ NNN		ऑक्टल नोटेशन, जहां n सीमा 0.7 में है
\ r	0x0d	कैरिज रिटर्न
\ रों	0x20	अंतरिक्ष
\ t	0x09	टैब
\ v	0x0b	लंबवत टैब
\एक्स		चरित्र x
\ xnn		हेक्साडेसिमल नोटेशन, जहां n 0.9, एफआर, या एएफ रेंज में है

अक्षरों को सांकेतिक अक्षरों में बदलना

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

आप इस तरह से अपने कार्यक्रम की शुरुआत में $ KCODE का उपयोग करके अपने चरित्र सेट को बदल सकते हैं -

$KCODE = 'u'

$ KCODE के लिए संभावित मूल्य निम्नलिखित हैं।

अनु क्रमांक।	कोड और विवरण
1	a ASCII (समान नहीं)। यह डिफ़ॉल्ट है।
2	e ईयूसी।
3	n कोई नहीं (ASCII के समान)
4	u UTF-8।

स्ट्रिंग में निर्मित तरीके

हमें स्ट्रिंग पद्धति को कॉल करने के लिए स्ट्रिंग ऑब्जेक्ट का एक उदाहरण होना चाहिए। निम्नलिखित स्ट्रिंग वस्तु का एक उदाहरण बनाने का तरीका है -

new [String.new(str = "")]

यह एक नया स्ट्रिंग ऑब्जेक्ट लौटाएगा जिसमें str की एक प्रति होगी । अब, str ऑब्जेक्ट का उपयोग करके , हम सभी किसी भी उपलब्ध इंस्टेंस विधियों का उपयोग कर सकते हैं। उदाहरण के लिए -

#!/usr/bin/ruby

myStr = String.new("THIS IS TEST")
foo = myStr.downcase

puts "#{foo}"

यह निम्नलिखित परिणाम का उत्पादन करेगा -

this is test

निम्नलिखित सार्वजनिक स्ट्रिंग विधियाँ हैं (मान लेना str एक स्ट्रिंग ऑब्जेक्ट है) -

अनु क्रमांक।	तरीके और विवरण
1	str % arg एक प्रारूप विनिर्देशन का उपयोग करके एक स्ट्रिंग को प्रारूपित करता है। अगर यह एक से अधिक प्रतिस्थापन है तो arg एक सरणी होना चाहिए। प्रारूप विनिर्देश के बारे में जानकारी के लिए, "कर्नेल मॉड्यूल" के तहत स्प्रिंट देखें।
2	str * integer एक नया स्ट्रिंग पूर्णांक बार str युक्त देता है। दूसरे शब्दों में, str को बार-बार पूर्णांक imes कहा जाता है।
3	str + other_str Concatenates other_str को str।
4	str << obj किसी वस्तु को str से समेटता है। यदि ऑब्जेक्ट 0.255 सीमा में एक Fixnum है, तो इसे एक वर्ण में बदल दिया जाता है। इसकी तुलना समास से करें।
5	str <=> other_str अन्य_स्ट्र के साथ तुलना करता है, -1 (से कम), 0 (बराबर), या 1 (अधिक से अधिक) लौटाता है। तुलना केस-संवेदी है।
6	str == obj समानता के लिए टेस्ट और ओबीजी। यदि ओब्ज स्ट्रिंग नहीं है, तो गलत है; रिटर्न सही है अगर str <=> obj रिटर्न 0।
7	str =~ obj एक रेगुलर एक्सप्रेशन पैटर्न ओबज के खिलाफ मैच मेल खाता है। वह स्थिति लौटाता है जहाँ मैच शुरू होता है; अन्यथा, गलत है।
8	str.capitalize एक स्ट्रिंग को बड़ा करता है।
9	str.capitalize! पूंजी के रूप में भी, लेकिन परिवर्तन जगह में किए गए हैं।
10	str.casecmp तार के मामले-असंवेदनशील बनाता है।
1 1	str.center केंद्र एक स्ट्रिंग।
12	str.chomp स्ट्रिंग के अंत से रिकॉर्ड विभाजक ($ /), आमतौर पर \ n निकालता है। यदि कोई रिकॉर्ड विभाजक मौजूद नहीं है, तो कुछ भी नहीं करता है।
13	str.chomp! धूमधाम के रूप में भी, लेकिन जगह में परिवर्तन किए जाते हैं।
14	str.chop पिछले वर्ण को निकालता है।
15	str.chop! काट के रूप में भी, लेकिन परिवर्तन जगह में किए गए हैं।
16	str.concat(other_str) Concatenates other_str को str।
17	str.count(str, ...) वर्णों के एक या अधिक सेट गिना जाता है। यदि वर्णों का एक से अधिक सेट है, तो उन सेटों के प्रतिच्छेदन को गिनता है
18	str.crypt(other_str) एक-तरफ़ा क्रिप्टोग्राफ़िक हैश को str में लागू करता है। तर्क नमक स्ट्रिंग है, जो दो वर्ण लंबा होना चाहिए, रेंज में प्रत्येक वर्ण az, AZ, 0.9,। या /।
19	str.delete(other_str, ...) हटाए गए अपने तर्कों के प्रतिच्छेदन में सभी वर्णों के साथ str की एक प्रति लौटाता है।
20	str.delete!(other_str, ...) डिलीट के रूप में भी, लेकिन परिवर्तन जगह में किए गए हैं।
21	str.downcase लोअरकेस के साथ प्रतिस्थापित सभी अपरकेस अक्षरों के साथ str की एक प्रति लौटाता है।
22	str.downcase! नीचे की तरह ही, लेकिन जगह में बदलाव किए जाते हैं।
23	str.dump सभी गैर-वर्णों वाले वर्णों का एक संस्करण लौटाता है जिसे \ nnn संकेतन द्वारा प्रतिस्थापित किया जाता है और सभी विशेष वर्ण बच जाते हैं।
24	str.each(separator = $/) { |substr| block } विभाजित विभाजक के रूप में तर्क का उपयोग करते हुए स्प्लिट्स ($ / डिफ़ॉल्ट रूप से), आपूर्ति किए गए ब्लॉक के प्रत्येक विकल्प को पास करते हुए।
25	str.each_byte { |fixnum| block } प्रत्येक बाइट को ब्लॉक के ऊपर से गुजरता है, प्रत्येक बाइट को बाइट के दशमलव प्रतिनिधित्व के रूप में लौटाता है।
26	str.each_line(separator=$/) { |substr| block } विभाजित विभाजक के रूप में तर्क का उपयोग करते हुए स्प्लिट्स ($ / डिफ़ॉल्ट रूप से), आपूर्ति किए गए ब्लॉक के प्रत्येक विकल्प को पास करते हुए।
27	str.empty? सही है अगर str खाली है (शून्य लंबाई है)।
28	str.eql?(other) दो तार बराबर हैं यदि उनकी लंबाई और सामग्री समान है।
29	str.gsub(pattern, replacement) [or] str.gsub(pattern) { |match| block } प्रतिरूप या ब्लॉक के मूल्य के साथ प्रतिस्थापित पैटर्न की सभी घटनाओं के साथ str की एक प्रति लौटाता है। पैटर्न आमतौर पर एक Regexp होगा; यदि यह एक स्ट्रिंग है, तो कोई भी नियमित अभिव्यक्ति मेटाचैकर्स की व्याख्या नहीं की जाएगी (अर्थात, / \ d / एक अंक से मेल खाएगी, लेकिन 'd' एक बैकस्लैश से मेल खाएगी, जो 'd' से होगा)
30	str[fixnum] [or] str[fixnum,fixnum] [or] str[range] [or] str[regexp] [or] str[regexp, fixnum] [or] str[other_str] निम्नलिखित तर्कों का उपयोग करते हुए संदर्भ: एक फिक्सनम, एक वर्ण कोड देता है; दो फ़िक्नेम्स, एक ऑफसेट (पहली फ़िक्नुम) से शुरू होकर लंबाई (दूसरा फ़िक्नुम) तक पहुँचता है; रेंज, रेंज में एक विकल्प देता है; मिलान स्ट्रिंग का regexp रिटर्न भाग; फ़िक्नम के साथ रीएग्क्सप, फ़िक्नम में डेटा का मिलान करता है; अन्य_स्ट्रस्ट अन्य_स्ट्रस्ट से मेल खाते हुए विकल्प हैं। एक नकारात्मक फिक्सनम स्ट्रिंग के अंत में शुरू होता है -1।
31	str[fixnum] = fixnum [or] str[fixnum] = new_str [or] str[fixnum, fixnum] = new_str [or] str[range] = aString [or] str[regexp] = new_str [or] str[regexp, fixnum] = new_str [or] str[other_str] = new_str ] एक स्ट्रिंग के सभी या भाग को बदलें (असाइन करें)। स्लाइस का पर्यायवाची !.
32	str.gsub!(pattern, replacement) [or] str.gsub!(pattern) { |match|block } स्ट्रिंग # gsub के प्रतिस्थापन को निष्पादित करता है, यदि कोई प्रतिस्थापन नहीं किया गया था, तो वापस लौटना या शून्य करना।
33	str.hash स्ट्रिंग की लंबाई और सामग्री के आधार पर एक हैश लौटाता है।
34	str.hex हेक्साडेसिमल अंकों की एक स्ट्रिंग (वैकल्पिक संकेत और एक वैकल्पिक 0x के साथ) के रूप में str से अग्रणी पात्रों का व्यवहार करता है और संबंधित संख्या देता है। शून्य त्रुटि पर दिया जाता है।
35	str.include? other_str [or] str.include? fixnum यदि स्ट्रिंग दी गई वर्ण या वर्ण में सही है, तो लौटाता है।
36	str.index(substring [, offset]) [or] str.index(fixnum [, offset]) [or] str.index(regexp [, offset]) दिए गए सबस्ट्रिंग, वर्ण (फ़िक्नम), या पैटर्न (regexp) की पहली घटना के सूचकांक को वापस लौटाता है। न मिलने पर वापस कर देता है। यदि दूसरा पैरामीटर मौजूद है, तो यह खोज शुरू करने के लिए स्ट्रिंग में स्थिति निर्दिष्ट करता है।
37	str.insert(index, other_str) दिए गए इंडेक्स में कैरेक्टर से पहले other_str सम्मिलित करता है, str को संशोधित करता है। नकारात्मक सूचकांक स्ट्रिंग के अंत से गिने जाते हैं, और दिए गए वर्ण के बाद सम्मिलित होते हैं। आशय एक स्ट्रिंग सम्मिलित करना है ताकि यह दिए गए सूचकांक पर शुरू हो।
38	str.inspect विशेष वर्णों से बचकर, str का एक मुद्रण योग्य संस्करण देता है।
39	str.intern [or] str.to_sym यदि यह पहले से मौजूद नहीं था, तो प्रतीक बनाते हुए, str को इसी सिंबल पर लौटाता है।
40	str.length Str की लंबाई देता है। आकार की तुलना करें।
41	str.ljust(integer, padstr = ' ') यदि पूर्णांक लंबाई की लंबाई से अधिक है, तो लंबाई के बराबर पूर्णांक के साथ एक नया स्ट्रिंग लौटाता है, जो कि उचित है और पैडस्ट के साथ गद्देदार है; अन्यथा, वापस लौट आता है।
42	str.lstrip हटाए गए प्रमुख व्हाट्सएप के साथ str की एक प्रति लौटाता है।
43	str.lstrip! कोई परिवर्तन नहीं किया गया था, तो वापस लौटने से प्रमुख व्हाट्सएप को हटा देता है।
44	str.match(pattern) एक Regexp के पैटर्न को परिवर्तित करता है (यदि यह पहले से ही एक नहीं है), तो str पर इसकी मैच विधि लागू करता है।
45	str.oct ऑक्टल अंकों की एक स्ट्रिंग के रूप में (एक वैकल्पिक संकेत के साथ) के प्रमुख पात्रों को मानता है और संबंधित संख्या देता है। रूपांतरण विफल होने पर 0 देता है।
46	str.replace(other_str) अन्य_स्ट्रस्ट में संबंधित मूल्यों के साथ स्ट्रिंग की सामग्री और दागीपन को प्रतिस्थापित करता है।
47	str.reverse उल्टे क्रम में str से वर्णों के साथ एक नया तार लौटाता है।
48	str.reverse! जगह-जगह उलटियां होती हैं।
49	str.rindex(substring [, fixnum]) [or] str.rindex(fixnum [, fixnum]) [or] str.rindex(regexp [, fixnum]) दिए गए सबस्ट्रिंग, वर्ण (फ़िक्नम), या पैटर्न (regexp) की अंतिम घटना के सूचकांक को वापस लौटाता है। न मिलने पर वापस कर देता है। यदि दूसरा पैरामीटर मौजूद है, तो यह खोज को समाप्त करने के लिए स्ट्रिंग में स्थिति निर्दिष्ट करता है। इस बिंदु से परे हटाने वालों पर विचार नहीं किया जाएगा।
50।	str.rjust(integer, padstr = ' ') यदि पूर्णांक लंबाई की लंबाई से अधिक है, तो लंबाई के पूर्णांक के साथ लंबाई पूर्णांक का नया स्ट्रिंग लौटाता है और पैडस्ट्र के साथ गद्देदार होता है; अन्यथा, वापस लौट आता है।
51	str.rstrip हटाए गए व्हाट्सएप के साथ स्ट्रोक की एक प्रति लौटाता है।
52	str.rstrip! कोई परिवर्तन नहीं किया गया था, तो वापस लौटने से, पीछे से व्हॉट्सएप का निशान हटाता है।
53	str.scan(pattern) [or] str.scan(pattern) { |match, ...| block } दोनों स्ट्रेट के माध्यम से पुनरावृति बनाते हैं, पैटर्न से मेल खाते हैं (जो एक Regexp या एक स्ट्रिंग हो सकता है)। प्रत्येक मैच के लिए, एक परिणाम उत्पन्न होता है और या तो परिणाम सरणी में जोड़ा जाता है या ब्लॉक में जाता है। यदि पैटर्न में कोई समूह नहीं है, तो प्रत्येक व्यक्तिगत परिणाम में मिलान स्ट्रिंग, $ & होता है। यदि पैटर्न में समूह होते हैं, तो प्रत्येक व्यक्तिगत परिणाम एक सरणी होता है जिसमें प्रति समूह एक प्रविष्टि होती है।
54	str.slice(fixnum) [or] str.slice(fixnum, fixnum) [or] str.slice(range) [or] str.slice(regexp) [or] str.slice(regexp, fixnum) [or] str.slice(other_str) See str[fixnum], etc. str.slice!(fixnum) [or] str.slice!(fixnum, fixnum) [or] str.slice!(range) [or] str.slice!(regexp) [or] str.slice!(other_str) निर्दिष्ट भाग को str से हटाता है, और हटाए गए भाग को वापस करता है। यदि फ़िक्नम लेने वाले फॉर्म एक IndexError बढ़ाएंगे यदि मूल्य सीमा से बाहर है; रेंज फॉर्म एक रेंजएयर उठाएगा, और रेगेक्सपी और स्ट्रिंग फॉर्म चुपचाप असाइनमेंट को अनदेखा कर देंगे।
55	str.split(pattern = $, [limit]) इन पदार्थों की एक सरणी को वापस करते हुए, एक सीमांकक के आधार पर सब्सट्रिंग्स में विभाजित होते हैं। यदि पैटर्न एक स्ट्रिंग है, तो स्ट्रेट को विभाजित करते समय इसकी सामग्री को सीमांकक के रूप में उपयोग किया जाता है। यदि पैटर्न एक ही स्थान है, तो व्हाट्सएप पर स्ट्रेट को विभाजित किया जाता है, जिसमें प्रमुख व्हाट्सएप और सन्निहित व्हाट्सएप के पात्रों को अनदेखा किया जाता है। यदि पैटर्न एक Regexp है, तो str को विभाजित किया जाता है जहां पैटर्न मैच करता है। जब भी पैटर्न एक शून्य-लंबाई वाली स्ट्रिंग से मेल खाता है, str व्यक्तिगत वर्णों में विभाजित होता है। यदि पैटर्न छोड़ा गया है, का मान$; is used. If $; nil है (जो कि डिफ़ॉल्ट है), str को व्हाट्सएप पर विभाजित किया जाता है जैसे कि `` निर्दिष्ट किए गए थे। यदि सीमा पैरामीटर को छोड़ दिया जाता है, तो ट्रेलिंग नल फ़ील्ड को दबा दिया जाता है। यदि सीमा एक सकारात्मक संख्या है, तो उस क्षेत्र की अधिकांश संख्या वापस आ जाएगी (यदि सीमा 1 है, तो संपूर्ण स्ट्रिंग को एक सरणी में केवल प्रविष्टि के रूप में लौटा दिया जाता है)। यदि ऋणात्मक है, तो लौटे हुए फ़ील्ड की संख्या की कोई सीमा नहीं है, और अनुगामी नल फ़ील्ड को दबाया नहीं जाता है।
56	str.squeeze([other_str]*) स्ट्रिंग # गिनती के लिए वर्णित प्रक्रिया का उपयोग करके अन्य_स्ट्राल पैरामीटर (ओं) से वर्णों का एक सेट बनाता है। एक नया स्ट्रिंग लौटाता है, जहां एक ही वर्ण के रन इस सेट में होते हैं जो एकल वर्ण द्वारा प्रतिस्थापित किए जाते हैं। यदि कोई तर्क नहीं दिया जाता है, तो समान वर्णों के सभी रन एकल वर्ण द्वारा प्रतिस्थापित किए जाते हैं।
57	str.squeeze!([other_str]*) यदि कोई परिवर्तन नहीं किया गया था, तो जगह-जगह पर निचोड़, या तो वापस लौट आए, या शून्य हो गए।
58	str.strip हटाई गई प्रमुख और अनुगामी व्हाट्सएप के साथ str की एक प्रति लौटाता है।
59	str.strip! प्रमुख और अनुगामी व्हाट्सएप को दूर से हटाता है। रिटर्न nil अगर str बदल नहीं गया था।
60	str.sub(pattern, replacement) [or] str.sub(pattern) { |match| block } पैटर्न की पहली घटना के साथ स्ट्रोक की एक प्रति लौटाता है या तो प्रतिस्थापन या ब्लॉक के मूल्य के साथ प्रतिस्थापित किया जाता है। पैटर्न आमतौर पर एक Regexp होगा; यदि यह एक स्ट्रिंग है तो कोई नियमित अभिव्यक्ति मेटाचैकर की व्याख्या नहीं की जाएगी।
61	str.sub!(pattern, replacement) [or] str.sub!(pattern) { |match| block } स्ट्रिंग # उप के स्थानापन्न को निष्पादित करता है, यदि कोई प्रतिस्थापन नहीं किया गया है, तो वापस लौटना, या शून्य करना।
62	str.succ [or] str.next उत्तराधिकारी को लौट जाता है।
63	str.succ! [or] str.next! स्ट्रिंग # succ के बराबर, लेकिन जगह में रिसीवर को संशोधित करता है।
64	str.sum(n = 16) Str में वर्णों का एक मूल n-बिट चेकसम लौटाता है, जहाँ n वैकल्पिक फिक्सनम पैरामीटर है, जो कि 16 में डिफ़ॉल्ट है। परिणाम केवल str modulo 2n में प्रत्येक वर्ण के बाइनरी मान का योग है - 1. यह विशेष रूप से नहीं है अच्छा चेकसम।
65	str.swapcase अपरकेस वर्णमाला के साथ str की एक प्रति लौटाता है जिसे लोअरकेस में परिवर्तित किया जाता है और अपरकेस अक्षरों को परिवर्तित किया जाता है।
66	str.swapcase! स्ट्रिंग # स्वैपकेस के बराबर, लेकिन रिसीवर में संशोधन करता है, यदि कोई परिवर्तन नहीं किया गया है, तो वापस लौट रहा है।
67	str.to_f > फ़्लोटिंग-पॉइंट संख्या के रूप में str में अग्रणी वर्णों की व्याख्या करने का परिणाम देता है। किसी मान्य संख्या के अंत में पिछले वर्णों को अनदेखा कर दिया जाता है। यदि प्रारंभ के समय कोई मान्य संख्या नहीं है, तो 0.0 लौटा दी जाती है। यह विधि कभी भी अपवाद नहीं उठाती है।
68	str.to_i(base = 10) पूर्णांक आधार (बेस 2, 8, 10, या 16) के रूप में str में अग्रणी वर्णों की व्याख्या करने का परिणाम देता है। किसी मान्य संख्या के अंत में पिछले वर्णों को अनदेखा कर दिया जाता है। यदि प्रारंभ के प्रारंभ में कोई मान्य संख्या नहीं है, तो 0 लौटा दी जाती है। यह विधि कभी भी अपवाद नहीं उठाती है।
69	str.to_s [or] str.to_str रिसीवर लौटा देता है।
70	str.tr(from_str, to_str) In_str से वर्णों के साथ str की एक प्रति लौटाता है जो in_str के संगत वर्णों द्वारा प्रतिस्थापित की जाती है। यदि to_str from_str से छोटा है, तो यह अपने अंतिम वर्ण के साथ गद्देदार है। दोनों तार वर्णों की श्रेणियों को निरूपित करने के लिए c1.c2 संकेतन का उपयोग कर सकते हैं, और from_str एक ^ से शुरू हो सकता है, जो सूचीबद्ध किए गए को छोड़कर सभी वर्णों को दर्शाता है।
71	str.tr!(from_str, to_str) String # tr के समान नियमों का उपयोग करते हुए, स्थान में अनुवाद करता है। यदि कोई परिवर्तन नहीं किया गया था, तो रिटर्न str या nil है।
72	str.tr_s(from_str, to_str) स्ट्रिंग # tr के तहत वर्णित str की एक प्रतिलिपि संसाधित करता है, फिर उन क्षेत्रों में डुप्लिकेट वर्णों को निकालता है जो अनुवाद से प्रभावित थे।
73	str.tr_s!(from_str, to_str) यदि कोई परिवर्तन नहीं किया गया था, तो स्ट्रिंग # tr_s प्रसंस्करण को स्ट्रिंग पर लौटाता है, या वापस लौटाता है।
74	str.unpack(format) > स्ट्रिंग स्ट्रिंग (जिसमें बाइनरी डेटा हो सकता है) प्रारूप स्ट्रिंग के अनुसार, निकाले गए प्रत्येक मान की एक सरणी लौटाता है। प्रारूप स्ट्रिंग में एकल-वर्ण निर्देश का एक क्रम होता है, जिसे सारणी 18 में संक्षेपित किया गया है। प्रत्येक निर्देश को एक संख्या द्वारा अनुसरण किया जा सकता है, इस निर्देश के साथ दोहराने के लिए समय की संख्या को दर्शाता है। एक तारांकन चिह्न (*) सभी शेष तत्वों का उपयोग करेगा। निर्देश sSiIlL प्रत्येक को अंडरस्कोर (_) द्वारा निर्दिष्ट प्रकार के लिए अंतर्निहित प्लेटफ़ॉर्म के मूल आकार का उपयोग करने के लिए हो सकता है; अन्यथा, यह एक प्लेटफ़ॉर्म-स्वतंत्र सुसंगत आकार का उपयोग करता है। प्रारूप स्ट्रिंग में रिक्त स्थान की अनदेखी की जाती है।
75	str.upcase सभी अपरकेस अक्षरों के साथ str की एक कॉपी को उनके अपरकेस समकक्षों के साथ बदल देता है। ऑपरेशन लोकल असंवेदनशील है। केवल a से z अक्षर प्रभावित होते हैं।
76	str.upcase! यदि परिवर्तन नहीं किए गए हैं, तो ऊपर लौटने के लिए str की सामग्री को बदल देता है।
77	str.upto(other_str) { |s| block } क्रमिक मूल्यों के माध्यम से Iterates, str पर शुरू होता है और अन्य_str समावेशी पर समाप्त होता है, ब्लॉक के बदले में प्रत्येक मूल्य को पारित करता है। प्रत्येक मान उत्पन्न करने के लिए स्ट्रिंग # succ विधि का उपयोग किया जाता है।

स्ट्रिंग निर्देश unpack

निम्नलिखित तालिका विधि स्ट्रिंग # अनपैक के लिए अनपैक निर्देशों को सूचीबद्ध करती है।

आदेश	रिटर्न	विवरण
ए	तार	अनुगामी नल और रिक्त स्थान के साथ।
ए	तार	स्ट्रिंग।
ख	तार	प्रत्येक वर्ण से बिट्स निकालता है (सबसे महत्वपूर्ण बिट पहले)।
ख	तार	प्रत्येक वर्ण से बिट्स निकालता है (कम से कम महत्वपूर्ण बिट पहले)।
सी	Fixnum	एक वर्ण को एक अहस्ताक्षरित पूर्णांक के रूप में निकालता है।
सी	Fixnum	किसी वर्ण को पूर्णांक के रूप में निकालता है।
डी, डी	फ्लोट	देशी डबल के रूप में आकार (डबल) वर्ण मानते हैं।
इ	फ्लोट	लिटिल बाइट क्रम में डबल के रूप में आकार (डबल) वर्णों का व्यवहार करता है।
इ	फ्लोट	बिटेंडियन बाइट क्रम में फ्लोट के रूप में आकार (फ्लोट) पात्रों को व्यवहार करता है।
एफ, एफ	फ्लोट	देशी फ्लोट के रूप में आकार (फ्लोट) वर्ण मानते हैं।
जी	फ्लोट	नेटवर्क बाइट क्रम में डबल के रूप में आकार (डबल) वर्ण मानते हैं।
जी	तार	नेटवर्क बाइट क्रम में फ्लोट के रूप में आकार (फ्लोट) वर्ण व्यवहार करता है।
एच	तार	प्रत्येक वर्ण से हेक्स निबल्स निकालता है (सबसे महत्वपूर्ण बिट पहले)
एच	तार	प्रत्येक चरित्र से हेक्स निबल्स निकालता है (कम से कम महत्वपूर्ण बिट पहले)।
मैं	पूर्णांक	साइज़ोफ़ (इंट) (संशोधित द्वारा _) क्रमबद्ध वर्णों को एक अहस्ताक्षरित देशी पूर्णांक के रूप में मानता है।
मैं	पूर्णांक	एक हस्ताक्षरित देशी पूर्णांक के रूप में आकार (int) (_ द्वारा संशोधित) क्रमिक वर्ण मानता है।
एल	पूर्णांक	एक निरंकुश देशी लंबे पूर्णांक के रूप में चार (_ द्वारा संशोधित) क्रमिक वर्ण मानता है।
एल	पूर्णांक	एक हस्ताक्षरित देशी लंबे पूर्णांक के रूप में चार (_ द्वारा संशोधित) क्रमिक वर्ण मानता है।
म	तार	उद्धरित-मुद्रण योग्य।
म	तार	Base64- एन्कोड।
एन	पूर्णांक	नेटवर्क बाइट ऑर्डर में चार अक्षरों को एक अहस्ताक्षरित लंबे समय तक मानता है।
n	Fixnum	नेटवर्क बाइट ऑर्डर में दो अक्षरों को एक अहस्ताक्षरित लघु के रूप में मानता है।
पी	तार	आकार सूचक (चार *) वर्णों को एक सूचक के रूप में मानते हैं, और संदर्भित स्थान से \ emph {len} वर्ण वापस करते हैं।
पी	तार	एक अशक्त-समाप्त स्ट्रिंग के लिए सूचक के रूप में आकार (चार *) वर्णों का व्यवहार करता है।
क्यू	पूर्णांक	आठ अक्षरों को एक अहस्ताक्षरित क्वाड शब्द (64 बिट्स) के रूप में मानता है।
क्यू	पूर्णांक	आठ अक्षरों को एक हस्ताक्षरित क्वाड शब्द (64 बिट्स) के रूप में मानता है।
रों	Fixnum	देशी बाइट क्रम में एक अहस्ताक्षरित लघु के रूप में दो (अलग-अलग अगर _ इस्तेमाल किए गए) क्रमिक अक्षरों को मानता है।
रों	Fixnum	देशी बाइट क्रम में एक हस्ताक्षरित लघु के रूप में दो (अलग अगर _ इस्तेमाल किया गया) क्रमिक वर्णों का व्यवहार करता है।
यू	पूर्णांक	अहस्ताक्षरित पूर्णांक के रूप में UTF-8 वर्ण।
यू	तार	UU एन्कोड।
वी	Fixnum	चार पात्रों को एक छोटे से बाइट क्रम में एक अहस्ताक्षरित लंबे समय तक मानता है।
v	Fixnum	लिटिल-एंडियन बाइट ऑर्डर में दो पात्रों को एक अहस्ताक्षरित लघु के रूप में मानता है।
w	पूर्णांक	BER- संपीड़ित पूर्णांक।
एक्स		एक पात्र को पीछे छोड़ता है।
एक्स		एक पात्र को छोड़ देता है।
जेड	तार	अनुगामी नल के साथ * पहले नल को हटा दिया गया।
@		लंबाई तर्क द्वारा दिए गए ऑफसेट को छोड़ देता है।

उदाहरण

विभिन्न डेटा को अनपैक करने के लिए निम्न उदाहरण का प्रयास करें।

"abc \0\0abc \0\0".unpack('A6Z6')   #=> ["abc", "abc "]
"abc \0\0".unpack('a3a3')           #=> ["abc", " \000\000"]
"abc \0abc \0".unpack('Z*Z*')       #=> ["abc ", "abc "]
"aa".unpack('b8B8')                 #=> ["10000110", "01100001"]
"aaa".unpack('h2H2c')               #=> ["16", "61", 97]
"\xfe\xff\xfe\xff".unpack('sS')     #=> [-2, 65534]
"now = 20is".unpack('M*')           #=> ["now is"]
"whole".unpack('xax2aX2aX1aX2a')    #=> ["h", "e", "l", "l", "o"]

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

सरणी अनुक्रमण 0 से शुरू होता है, जैसे C या Java में। एक नकारात्मक सूचकांक को सरणी के अंत के सापेक्ष माना जाता है --- अर्थात -1 का सूचकांक सरणी के अंतिम तत्व को इंगित करता है, -2 सरणी में अंतिम तत्व के बगल में है, और इसी तरह।

रूबी सरणियां स्ट्रिंग, इंटेगर, फिक्सनम, हैश, सिंबल, यहां तक ​​कि अन्य ऐरे ऑब्जेक्ट्स जैसी वस्तुओं को पकड़ सकती हैं। रूबी सरणियों अन्य भाषाओं में सरणियों के रूप में कठोर नहीं हैं। तत्वों को जोड़ने के दौरान रूबी सरणियाँ अपने आप बढ़ जाती हैं।

ऐरे बनाना

किसी सरणी को बनाने या आरंभ करने के कई तरीके हैं। एक तरीका नए वर्ग विधि के साथ है -

names = Array.new

आप सरणी बनाने के समय एक सरणी का आकार निर्धारित कर सकते हैं -

names = Array.new(20)

सरणी नामों में अब 20 तत्वों का आकार या लंबाई है। आप किसी सरणी के आकार को आकार या लंबाई के तरीकों से वापस कर सकते हैं -

#!/usr/bin/ruby

names = Array.new(20)
puts names.size  # This returns 20
puts names.length # This also returns 20

यह निम्नलिखित परिणाम का उत्पादन करेगा -

20
20

आप सरणी में प्रत्येक तत्व के लिए एक मूल्य प्रदान कर सकते हैं -

#!/usr/bin/ruby

names = Array.new(4, "mac")
puts "#{names}"

यह निम्नलिखित परिणाम का उत्पादन करेगा -

["mac", "mac", "mac", "mac"]

आप नए तत्व के साथ ब्लॉक का भी उपयोग कर सकते हैं, प्रत्येक तत्व को पॉप्युलेट करता है जो ब्लॉक का मूल्यांकन करता है -

#!/usr/bin/ruby

nums = Array.new(10) { |e| e = e * 2 }
puts "#{nums}"

यह निम्नलिखित परिणाम का उत्पादन करेगा -

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

ऐरे की एक और विधि है, []। यह इस तरह काम करता है -

nums = Array.[](1, 2, 3, 4,5)

सरणी निर्माण का एक और रूप इस प्रकार है -

nums = Array[1, 2, 3, 4,5]

कर्नेल मॉड्यूल कोर रूबी में उपलब्ध किसी सरणी विधि है, जो केवल एक ही तर्क को स्वीकार करता है। यहाँ, विधि एक सारणी बनाती है एक तर्क के रूप में एक अंक बनाने के लिए -

#!/usr/bin/ruby

digits = Array(0..9)
puts "#{digits}"

यह निम्नलिखित परिणाम का उत्पादन करेगा -

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

एरे बिल्ट-इन मेथड्स

हमें ऐरे विधि को कॉल करने के लिए ऐरे ऑब्जेक्ट का एक उदाहरण होना चाहिए। जैसा कि हमने देखा है, एरे ऑब्जेक्ट का एक उदाहरण बनाने का तरीका निम्नलिखित है -

Array.[](...) [or] Array[...] [or] [...]

यह दी गई वस्तुओं के साथ आबाद एक नया सरणी लौटाएगा। अब, बनाई गई वस्तु का उपयोग करके, हम किसी भी उपलब्ध उदाहरण के तरीकों को कॉल कर सकते हैं। उदाहरण के लिए -

#!/usr/bin/ruby

digits = Array(0..9)
num = digits.at(6)
puts "#{num}"

यह निम्नलिखित परिणाम का उत्पादन करेगा -

6

निम्नलिखित सार्वजनिक सरणी विधियाँ हैं (मान लेना एक सरणी वस्तु है) -

अनु क्रमांक।	तरीके और विवरण
1	array & other_array कोई भी डुप्लिकेट के साथ दो सरणियों के लिए आम तत्वों युक्त एक नया सरणी देता है।
2	array * int [or] array * str स्व की अंतर प्रतियों को समेट कर बनाया गया एक नया सरणी लौटाता है। एक स्ट्रिंग तर्क के साथ, स्व.जॉइन (str) के बराबर।
3	array + other_array तीसरा सरणी उत्पन्न करने के लिए एक साथ दो सरणियों को समेटकर बनाया गया एक नया सरणी देता है।
4	array - other_array एक नई सरणी देता है जो मूल सरणी की एक प्रति है, जो किसी भी आइटम को हटाती है जो अन्य_अरे में भी दिखाई देती है।
5	array <=> other_array अन्य_स्ट्र के साथ तुलना करता है, -1 (से कम), 0 (बराबर), या 1 (अधिक से अधिक) लौटाता है। तुलनात्मक है।
6	array | other_array डुप्लिकेट को हटाकर, दूसरे_अरे के साथ एरे से जुड़कर एक नया एरे लौटाता है।
7	array << obj सरणी के अंत में दी गई वस्तु को दबाता है। यह अभिव्यक्ति स्वयं ही सरणी लौटाती है, इसलिए कई एप्स एक साथ जंजीर हो सकते हैं।
8	array <=> other_array पूर्णांक देता है (-1, 0, या +1) यदि यह सरणी अन्य के मुकाबले कम, बराबर या उससे अधिक है।
9	array == other_array दो एरे समान होते हैं यदि उनमें समान तत्वों की संख्या होती है और यदि प्रत्येक तत्व दूसरे एरे में संबंधित एलीमेंट (ऑब्जेक्ट। ==) के बराबर होता है।
10	array[index] [or] array[start, length] [or] array[range] [or] array.slice(index) [or] array.slice(start, length) [or] array.slice(range) तत्व को इंडेक्स पर लौटाता है, या लंबाई तत्वों के लिए शुरू और जारी रखने के लिए एक सबर्रे लौटाता है, या रेंज द्वारा निर्दिष्ट सबर्रे देता है । ऋणात्मक सूचकांक सरणी के अंत से पीछे की ओर गिनती करते हैं (-1 अंतिम तत्व है)। यदि इंडेक्स (या स्टार्टिंग इंडेक्स) सीमा से बाहर है, तो शून्य लौटाता है ।
1 1	array[index] = obj [or] array[start, length] = obj or an_array or nil [or] array[range] = obj or an_array or nil तत्व को इंडेक्स पर सेट करता है , या लंबाई तत्वों के लिए शुरू और जारी रखने के लिए एक सबर्रे की जगह लेता है, या रेंज द्वारा निर्दिष्ट एक सब्रे को बदलता है । यदि सूचक सरणी की वर्तमान क्षमता से अधिक हैं, तो सरणी स्वचालित रूप से बढ़ती है। ऋणात्मक सूचकांक सरणी के अंत से पिछड़े की गणना करेंगे। लंबाई शून्य होने पर तत्वों को सम्मिलित करता है। यदि शून्य का उपयोग दूसरे और तीसरे रूप में किया जाता है, तो स्वयं से तत्वों को हटा देता है ।
12	array.abbrev(pattern = nil) स्वयं में तार के लिए स्पष्ट दृष्टिकोण के सेट की गणना करता है । यदि एक पैटर्न या एक स्ट्रिंग पास की जाती है, तो केवल पैटर्न से मेल खाते या स्ट्रिंग से शुरू होने वाले तार को माना जाता है।
13	array.assoc(obj) एक ऐसे सरणी के माध्यम से खोज करता है, जिसके तत्व भी obj का उपयोग करते हुए प्रत्येक समाहित सरणी के पहले तत्व के साथ obj की तुलना करते हैं। == यदि कोई मैच नहीं मिला है तो पहला निहित सरणी देता है जो मेल खाता है या शून्य करता है।
14	array.at(index) इंडेक्स पर तत्व देता है। एक नकारात्मक सूचकांक स्वयं के अंत से मायने रखता है। यदि सूचकांक सीमा से बाहर है, तो शून्य लौटाता है।
15	array.clear सरणी से सभी तत्वों को निकालता है।
16	array.collect { |item| block } [or] array.map { |item| block } स्वयं के प्रत्येक तत्व के लिए एक बार ब्लॉक को आमंत्रित करता है । ब्लॉक द्वारा लौटाए गए मानों से युक्त एक नई सरणी बनाता है।
17	array.collect! { |item| block } [or] array.map! { |item| block } Invokes ब्लॉक के प्रत्येक तत्व के लिए एक बार आत्म , द्वारा दिए गए मान के साथ तत्व की जगह ब्लॉक ।
18	array.compact हटाए गए सभी शून्य तत्वों के साथ स्वयं की एक प्रति लौटाता है।
19	array.compact! सरणी से शून्य तत्व निकालता है । रिटर्न शून्य अगर कोई बदलाव नहीं किए गए थे।
20	array.concat(other_array) अन्य तत्वों को स्वयं में लागू करता है ।
21	array.delete(obj) [or] array.delete(obj) { block } स्वयं से आइटम हटाता है जो obj के बराबर हैं । यदि आइटम नहीं मिला है, तो शून्य लौटाता है । यदि वैकल्पिक कोड ब्लॉक दिया गया है, तो आइटम नहीं मिलने पर ब्लॉक का परिणाम लौटाता है।
22	array.delete_at(index) निर्दिष्ट पर तत्व को हटा देता सूचकांक , उस तत्व लौटने, या नहीं के बराबर है, तो अनुक्रमणिका सीमा से बाहर है।
23	array.delete_if { |item| block } स्वयं के प्रत्येक तत्व को हटाता है जिसके लिए ब्लॉक सच का मूल्यांकन करता है।
24	array.each { |item| block } कॉल स्वयं में प्रत्येक तत्व के लिए एक बार ब्लॉक करता है , उस तत्व को एक पैरामीटर के रूप में पारित करता है।
25	array.each_index { |index| block } समान # के रूप में समान है, लेकिन तत्व के बजाय तत्व के सूचकांक को पास करता है।
26	array.empty? यदि स्व सरणी में कोई तत्व नहीं है, तो यह सही है।
27	array.eql?(other) यदि सरणी और अन्य समान ऑब्जेक्ट हैं, या दोनों एक ही सामग्री के साथ सरणियाँ हैं, तो सही है।
28	array.fetch(index) [or] array.fetch(index, default) [or] array.fetch(index) { |index| block } स्थिति सूचकांक में तत्व को वापस करने की कोशिश करता है । यदि इंडेक्स सरणी के बाहर स्थित है, तो पहला फॉर्म इंडेक्सइयर अपवाद को छोड़ता है, दूसरा फॉर्म डिफ़ॉल्ट रूप से वापस आता है , और तीसरा फॉर्म इंडेक्स में पास होने वाले ब्लॉक को लागू करने का मान देता है । सरणी के अंत से सूचकांक गणना के नकारात्मक मूल्य ।
29	array.fill(obj) [or] array.fill(obj, start [, length]) [or] array.fill(obj, range) [or] array.fill { |index| block } [or] array.fill(start [, length] ) { |index| block } [or] array.fill(range) { |index| block } पहले तीन रूपों ने स्वयं के चयनित तत्वों को ओबज के लिए निर्धारित किया । शून्य की एक शुरुआत शून्य के बराबर है। शून्य की एक लंबाई स्वयं के बराबर है । अंतिम तीन रूप ब्लॉक के मान के साथ सरणी को भरते हैं । ब्लॉक के साथ प्रत्येक तत्व का पूर्ण सूचकांक भरे जाने के लिए पारित कर दिया है।
30	array.first [or] array.first(n) सरणी का पहला तत्व, या पहला n तत्व देता है। यदि सरणी खाली है, तो पहला फ़ॉर्म शून्य पर लौटता है , और दूसरा फ़ॉर्म खाली सरणी देता है।
31	array.flatten एक नया सरणी लौटाता है जो इस सरणी (पुनरावर्ती) का एक आयामी आयाम है।
32	array.flatten! जगह में चपटा सरणी । रिटर्न शून्य यदि कोई संशोधन किए गए थे। (सरणी में कोई सबरेज़ नहीं है।)
33	array.frozen? सही है अगर सरणी जमी है (या अस्थायी रूप से सॉर्ट किए जाने के दौरान जमे हुए)।
34	array.hash सरणी के लिए हैश-कोड की गणना करता है। समान सामग्री वाले दो सरणियों का समान हैश कोड होगा।
35	array.include?(obj) सही है अगर obj स्वयं में मौजूद है , तो झूठे अन्यथा।
36	array.index(obj) स्व में पहली वस्तु का सूचकांक लौटाता है जो == से ओबज तक है। रिटर्न शून्य अगर कोई मुकाबला नहीं पाया जाता है।
37	array.indexes(i1, i2, ... iN) [or] array.indices(i1, i2, ... iN) इस तरीके को रूबी के नवीनतम संस्करण में चित्रित किया गया है, इसलिए कृपया Array # values_at का उपयोग करें।
38	array.indices(i1, i2, ... iN) [or] array.indexes(i1, i2, ... iN) इस तरीके को रूबी के नवीनतम संस्करण में चित्रित किया गया है, इसलिए कृपया Array # values_at का उपयोग करें।
39	array.insert(index, obj...) दिए गए सूचकांक के साथ तत्व से पहले दिए गए मूल्यों को सम्मिलित करता है (जो नकारात्मक हो सकता है)।
40	array.inspect सरणी का एक मुद्रण योग्य संस्करण बनाता है।
41	array.join(sep = $,) सरणी के प्रत्येक तत्व को एक स्ट्रिंग में परिवर्तित करके बनाई गई स्ट्रिंग लौटाता है, sep द्वारा अलग किया जाता है ।
42	array.last [or] array.last(n) स्व के अंतिम तत्व को लौटाता है । यदि सरणी खाली है , तो पहला फ़ॉर्म शून्य हो जाता है ।
43	array.length स्वयं में तत्वों की संख्या लौटाता है । शून्य हो सकता है।
44	array.map { |item| block } [or] array.collect { |item| block } स्वयं के प्रत्येक तत्व के लिए एक बार ब्लॉक को आमंत्रित करता है । ब्लॉक द्वारा लौटाए गए मानों से युक्त एक नई सरणी बनाता है ।
45	array.map! { |item| block } [or] array.collect! { |item| block } Invokes ब्लॉक के प्रत्येक तत्व के लिए एक बार सरणी , ब्लॉक द्वारा दिए गए मान के साथ तत्व की जगह।
46	array.nitems स्वयं में गैर-शून्य तत्वों की संख्या लौटाता है । शून्य हो सकता है।
47	array.pack(aTemplateString) टेम्प्लेटस्ट्रिंग में निर्देशों के अनुसार सरणी की सामग्री को एक बाइनरी अनुक्रम में पैक करता है। निर्देश ए, ए, और जेड का एक गणना द्वारा पालन किया जा सकता है, जो परिणामी क्षेत्र की चौड़ाई देता है। शेष निर्देशों में एक गिनती भी हो सकती है, जो परिवर्तित करने के लिए सरणी तत्वों की संख्या को दर्शाती है। यदि गणना एक तारांकन चिह्न (*) है, तो सभी शेष सरणी तत्व परिवर्तित हो जाएंगे। किसी भी निर्देश का अभी भी एक अंडरस्कोर (_) द्वारा निर्दिष्ट प्रकार के लिए अंतर्निहित प्लेटफ़ॉर्म के मूल आकार का उपयोग करने के लिए किया जा सकता है; अन्यथा, वे एक प्लेटफ़ॉर्म स्वतंत्र आकार का उपयोग करते हैं। टेम्पलेट स्ट्रिंग में रिक्त स्थान की अनदेखी की जाती है।
48	array.pop से पिछले तत्व निकालता सरणी और यह रिटर्न, या नहीं के बराबर है, तो सरणी खाली है।
49	array.push(obj, ...) इस सरणी के अंत में दिए गए आब्जेक्शन को पुश करता है (जोड़ता है)। यह अभिव्यक्ति स्वयं ही सरणी लौटाती है, इसलिए कई एप्स एक साथ जंजीर हो सकते हैं।
50	array.rassoc(key) उस सरणी के माध्यम से खोज करता है जिसके तत्व भी सरणियाँ हैं। == का उपयोग कर प्रत्येक निहित सरणी के दूसरे तत्व के साथ कुंजी की तुलना करता है । पहले समाहित सरणी देता है जो मेल खाता है।
51	array.reject { |item| block } आइटम वाले एक नई सरणी रिटर्न सरणी है जिसके लिए ब्लॉक नहीं है सच ।
52	array.reject! { |item| block } से हटाता तत्वों सरणी है जिसके लिए के लिए ब्लॉक मूल्यांकन करता है सच है, लेकिन रिटर्न शून्य अगर कोई बदलाव नहीं किए गए थे। Array # delete_if के बराबर।
53	array.replace(other_array) की सामग्री को बदल देता है की सामग्री के साथ other_array , छोटा या यदि आवश्यक हो तो विस्तार।
54	array.reverse एक नया सरणी देता है जिसमें सरणी के तत्व उल्टे क्रम में होते हैं।
55	array.reverse! जगह में उलट सरणी ।
56	array.reverse_each {|item| block } Array # प्रत्येक के रूप में समान है, लेकिन पीछे क्रम में सरणी को पीछे छोड़ता है।
57	array.rindex(obj) सरणी में अंतिम वस्तु के सूचकांक == को obj पर लौटाता है। रिटर्न शून्य अगर कोई मुकाबला नहीं पाया जाता है।
58	array.select {|item| block } सरणी से क्रमिक तत्वों में गुजरने वाले ब्लॉक को आमंत्रित करता है, उन तत्वों से युक्त एक सरणी लौटाता है जिसके लिए ब्लॉक एक सही मूल्य देता है ।
59	array.shift स्वयं का पहला तत्व लौटाता है और उसे हटा देता है (अन्य सभी तत्वों को एक-एक करके नीचे स्थानांतरित करता है)। यदि सरणी खाली है तो शून्य लौटाता है।
60	array.size सरणी की लंबाई (तत्वों की संख्या) लौटाता है । लंबाई के लिए उपनाम।
61	array.slice(index) [or] array.slice(start, length) [or] array.slice(range) [or] array[index] [or] array[start, length] [or] array[range] तत्व को इंडेक्स पर लौटाता है, या लंबाई तत्वों के लिए शुरू और जारी रखने के लिए एक सबर्रे लौटाता है, या रेंज द्वारा निर्दिष्ट सबर्रे देता है । ऋणात्मक सूचकांक सरणी के अंत से पीछे की ओर गिनती करते हैं (-1 अंतिम तत्व है)। यदि इंडेक्स (या स्टार्टिंग इंडेक्स) सीमा से बाहर है, तो शून्य लौटाता है ।
62	array.slice!(index) [or] array.slice!(start, length) [or] array.slice!(range) एक सूचकांक (वैकल्पिक रूप से एक लंबाई के साथ) या एक श्रेणी द्वारा दिए गए तत्व को हटाता है । यदि अनुक्रमणिका सीमा से बाहर है , तो हटाए गए ऑब्जेक्ट, सबर्रे या नील को लौटाता है ।
63	array.sort [or] array.sort { | a,b | block } स्व को छाँटकर बनाया गया नया सरणी देता है।
64	array.sort! [or] array.sort! { | a,b | block } आत्मदेव कहते हैं।
65	array.to_a स्व लौटाता है । अगर एरे के उपवर्ग पर कॉल किया जाता है , तो रिसीवर को एक ऐरे ऑब्जेक्ट में कनवर्ट करता है।
66	array.to_ary स्व लौटाता है।
67	array.to_s स्वंय लौट आता है।
68	array.transpose मान लेता है कि स्वयं सरणी का एक सरणी है और पंक्तियों और स्तंभों को स्थानांतरित करता है।
69	array.uniq में डुप्लिकेट मानों को निकाल कर एक नई सरणी रिटर्न सरणी ।
70	array.uniq! स्वयं से डुप्लिकेट तत्वों को निकालता है । यदि कोई परिवर्तन नहीं किया जाता है तो रिटर्न शून्य हो जाता है (यानी कोई डुप्लिकेट नहीं मिलता है)।
71	array.unshift(obj, ...) सरणी के सामने की ओर वस्तुओं को प्रस्तुत करता है, अन्य तत्व एक ऊपर।
72	array.values_at(selector,...) दिए गए चयनकर्ता (एक या अधिक) के अनुरूप स्वयं में तत्वों से युक्त एक सरणी देता है । चयनकर्ता पूर्णांक सूचक या श्रेणी हो सकते हैं।
73	array.zip(arg, ...) [or] array.zip(arg, ...){ | arr | block } किसी भी तर्क को सरणियों में परिवर्तित करता है, फिर प्रत्येक तर्क से संबंधित तत्वों के साथ सरणी के तत्वों को मर्ज करता है।

ऐरे पैक निर्देश

निम्न तालिका Array # पैक के साथ उपयोग के लिए पैक निर्देशों को सूचीबद्ध करती है।

अनु क्रमांक।	निर्देश और विवरण
1	@ निरपेक्ष स्थिति में ले जाता है।
2	A ASCII स्ट्रिंग (अंतरिक्ष गद्देदार, गिनती चौड़ाई है)।
3	a ASCII स्ट्रिंग (शून्य गद्देदार, गिनती चौड़ाई है)।
4	B स्ट्रिंग (अवरोही बिट क्रम)।
5	b बिट स्ट्रिंग (आरोही बिट ऑर्डर)।
6	C अचिन्हित वर्ण।
7	c चार।
8	D, d डबल-सटीक फ्लोट, देशी प्रारूप।
9	E डबल-सटीक फ्लोट, लिटिल-एंडियन बाइट ऑर्डर।
10	e एकल-सटीक फ्लोट, लिटिल-एंडियन बाइट ऑर्डर।
1 1	F, f एकल-सटीक फ्लोट, देशी प्रारूप।
12	G डबल-सटीक फ्लोट, नेटवर्क (बिग-एंडियन) बाइट ऑर्डर।
13	g एकल-सटीक फ्लोट, नेटवर्क (बिग-एंडियन) बाइट ऑर्डर।
14	H हेक्स स्ट्रिंग (पहले उच्च कुतरना)।
15	h हेक्स स्ट्रिंग (कम नीबेल पहले)।
16	I निरुपित पूर्णांक।
17	i पूर्णांक।
18	L लंबे समय के बाद।
19	l लंबा।
20	M मुद्रित करने योग्य, MIME एन्कोडिंग (RFC 2045 देखें)।
21	m Base64- एन्कोडेड स्ट्रिंग।
22	N लंबा, नेटवर्क (बड़ा-एंडियन) बाइट ऑर्डर।
23	n शॉर्ट, नेटवर्क (बिग-एंडियन) बाइट ऑर्डर।
24	P एक संरचना को इंगित करता है (निश्चित-लंबाई स्ट्रिंग)।
25	p एक शून्य-समाप्त स्ट्रिंग को इंगित करता है।
26	Q, q 64-बिट संख्या।
27	S अकारण छोटा।
28	s कम।
29	U UTF-8।
30	u UU- एन्कोडेड स्ट्रिंग।
31	V लंबे, छोटे-एंडियन बाइट ऑर्डर।
32	v लघु, छोटे-एंडियन बाइट क्रम।
33	w BER- संकुचित पूर्णांक \ fnm।
34	X एक बाइट का बैकअप लें।
35	x नल बाइट।
36	Z एक के रूप में ही, सिवाय इसके कि अशक्त * के साथ जोड़ा जाता है।

उदाहरण

विभिन्न डेटा पैक करने के लिए निम्न उदाहरण का प्रयास करें।

a = [ "a", "b", "c" ]
n = [ 65, 66, 67 ]
puts a.pack("A3A3A3")   #=> "a  b  c  "
puts a.pack("a3a3a3")   #=> "a\000\000b\000\000c\000\000"
puts n.pack("ccc")      #=> "ABC"

यह निम्नलिखित परिणाम का उत्पादन करेगा -

a  b  c
abc
ABC

हैश इस तरह के-वैल्यू जोड़े का एक संग्रह है: "कर्मचारी" => "वेतन"। यह एक ऐरे के समान है, सिवाय इसके कि इंडेक्सिंग किसी ऑब्जेक्ट प्रकार की मनमानी कुंजी के माध्यम से किया जाता है, न कि एक पूर्णांक सूचकांक।

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

हैशिंग बनाना

सरणियों के साथ, हैश बनाने के विभिन्न तरीके हैं। आप नए वर्ग विधि के साथ एक खाली हैश बना सकते हैं -

months = Hash.new

आप डिफ़ॉल्ट मान के साथ हैश बनाने के लिए नए का उपयोग कर सकते हैं , जो अन्यथा शून्य है -

months = Hash.new( "month" )

or

months = Hash.new "month"

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

#!/usr/bin/ruby

months = Hash.new( "month" )

puts "#{months[0]}"
puts "#{months[72]}"

यह निम्नलिखित परिणाम का उत्पादन करेगा -

month
month

#!/usr/bin/ruby

H = Hash["a" => 100, "b" => 200]

puts "#{H['a']}"
puts "#{H['b']}"

यह निम्नलिखित परिणाम का उत्पादन करेगा -

100
200

आप किसी भी रूबी ऑब्जेक्ट को एक कुंजी या मान, यहां तक ​​कि एक सरणी के रूप में उपयोग कर सकते हैं, इसलिए निम्न उदाहरण एक मान्य है -

[1,"jan"] => "January"

हैश बिल्ट-इन मेथड्स

हमें हैश विधि को कॉल करने के लिए हैश ऑब्जेक्ट का एक उदाहरण होना चाहिए। जैसा कि हमने देखा है, निम्नलिखित हैश ऑब्जेक्ट का एक उदाहरण बनाने का तरीका है -

Hash[[key =>|, value]* ] or

Hash.new [or] Hash.new(obj) [or]
Hash.new { |hash, key| block }

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

#!/usr/bin/ruby

$, = ", "
months = Hash.new( "month" )
months = {"1" => "January", "2" => "February"}

keys = months.keys
puts "#{keys}"

यह निम्नलिखित परिणाम का उत्पादन करेगा -

["1", "2"]

निम्नलिखित सार्वजनिक हैश विधियाँ हैं ( हैश एक सरणी वस्तु है) -

अनु क्रमांक।	तरीके और विवरण
1	hash == other_hash टेस्ट कि क्या दो हैश बराबर हैं, इस आधार पर कि क्या उनके पास कुंजी-मूल्य जोड़े की समान संख्या है, और क्या कुंजी-मूल्य जोड़े प्रत्येक हैश में संबंधित जोड़ी से मेल खाते हैं।
2	hash.[key] एक कुंजी का उपयोग करना, हैश से एक मूल्य का संदर्भ देता है। यदि कुंजी नहीं मिली है, तो डिफ़ॉल्ट मान लौटाता है।
3	hash.[key] = value मूल्य द्वारा दिए गए मूल्य को कुंजी द्वारा दिए गए कुंजी के साथ जोड़ता है ।
4	hash.clear हैश से सभी कुंजी-मूल्य जोड़े निकालता है।
5	hash.default(key = nil) हैश के लिए डिफ़ॉल्ट मान लौटाता है , यदि डिफ़ॉल्ट रूप से सेट नहीं किया गया है तो nil =। ([] यदि हैश में कुंजी मौजूद नहीं है तो एक डिफ़ॉल्ट मान लौटाता है ।)
6	hash.default = obj हैश के लिए एक डिफ़ॉल्ट मान सेट करता है ।
7	hash.default_proc यदि एक ब्लॉक द्वारा हैश बनाया गया था तो एक रिटर्न देता है ।
8	hash.delete(key) [or] array.delete(key) { |key| block } से एक कुंजी-मान पेयर को हटाता है हैश द्वारा कुंजी । यदि ब्लॉक का उपयोग किया जाता है, तो जोड़ी नहीं मिलने पर ब्लॉक का परिणाम देता है। Delete_if की तुलना करें ।
9	hash.delete_if { |key,value| block } हर जोड़ी के लिए हैश से एक कुंजी-मूल्य जोड़ी हटाता है जो ब्लॉक सही का मूल्यांकन करता है ।
10	hash.each { |key,value| block } हैश पर Iterates , प्रत्येक कुंजी के लिए एक बार ब्लॉक को कॉल करते हुए, कुंजी-मान को दो-तत्व सरणी के रूप में पास करना।
1 1	hash.each_key { |key| block } हैश पर Iterates , प्रत्येक कुंजी के लिए एक बार ब्लॉक को कॉल करना, एक पैरामीटर के रूप में कुंजी पारित करना।
12	hash.each_key { |key_value_array| block } हैश पर Iterates , प्रत्येक कुंजी के लिए एक बार ब्लॉक को बुलाता है , कुंजी और मान को मापदंडों के रूप में पारित करता है।
13	hash.each_key { |value| block } हैश पर Iterates , प्रत्येक कुंजी के लिए एक बार ब्लॉक को बुलाता है , एक पैरामीटर के रूप में मान गुजरता है ।
14	hash.empty? टेस्ट हैश है कि खाली है (कोई कुंजी-मूल्य जोड़े शामिल हैं), सच या गलत लौटने ।
15	hash.fetch(key [, default] ) [or] hash.fetch(key) { | key | block } दिए गए कुंजी के लिए हैश से एक मान लौटाता है । यदि कुंजी नहीं मिल सकती है, और कोई अन्य तर्क नहीं है, तो यह एक IndexError अपवाद उठाता है; यदि डिफ़ॉल्ट दिया जाता है, तो उसे लौटा दिया जाता है; यदि वैकल्पिक ब्लॉक निर्दिष्ट किया जाता है, तो इसका परिणाम वापस आ जाता है।
16	hash.has_key?(key) [or] hash.include?(key) [or] hash.key?(key) [or] hash.member?(key) टेस्ट दिया गया है कि क्या दी गई कुंजी हैश में मौजूद है, सही या गलत लौटना ।
17	hash.has_value?(value) टेस्ट हैश में दिए गए मान शामिल हैं या नहीं ।
18	hash.index(value) हैश में दिए गए मान के लिए कुंजी लौटाता है , यदि कोई मिलान मूल्य नहीं मिलता है तो शून्य करें ।
19	hash.indexes(keys) दिए गए कुंजी के लिए मूल्यों से मिलकर एक नया सरणी देता है। नहीं मिलने वाली कुंजियों के लिए डिफ़ॉल्ट मान सम्मिलित करेंगे। यह विधि पदावनत है। चयन का उपयोग करें।
20	hash.indices(keys) दिए गए कुंजी के लिए मूल्यों से मिलकर एक नया सरणी देता है। नहीं मिलने वाली कुंजियों के लिए डिफ़ॉल्ट मान सम्मिलित करेंगे। यह विधि पदावनत है। चयन का उपयोग करें।
21	hash.inspect हैश का एक सुंदर प्रिंट स्ट्रिंग संस्करण लौटाता है।
22	hash.invert एक नया बनाता है हैश , inverting कुंजी और मूल्यों से हैश ; यह है कि, नए हैश में, से चाबी हैश बन मूल्यों और मूल्यों कुंजी बन जाते हैं।
23	hash.keys हैश से कुंजियों के साथ एक नया सरणी बनाता है ।
24	hash.length हैश का आकार या लंबाई पूर्णांक के रूप में देता है।
25	hash.merge(other_hash) [or] hash.merge(other_hash) { |key, oldval, newval| block } हैश और अन्य_हाश की सामग्री युक्त एक नया हैश लौटाता है , जो अन्य हैश के साथ डुप्लिकेट कुंजियों के साथ हैश में जोड़े को ओवरराइट करता है ।
26	hash.merge!(other_hash) [or] hash.merge!(other_hash) { |key, oldval, newval| block } मर्ज के रूप में भी, लेकिन परिवर्तन जगह में किया जाता है।
27	hash.rehash प्रत्येक कुंजी के लिए वर्तमान मानों के आधार पर रीबिल्ड हैश । यदि मान डाले जाने के बाद से मान बदल गए हैं, तो यह विधि हैश की गणना करती है ।
28	hash.reject { |key, value| block } प्रत्येक जोड़ी के लिए एक नया हैश बनाता है जो ब्लॉक सही का मूल्यांकन करता है
29	hash.reject! { |key, value| block } अस्वीकार के रूप में भी , लेकिन परिवर्तन जगह में किए गए हैं।
30	hash.replace(other_hash) अन्य हैश की सामग्री के साथ हैश की सामग्री को प्रतिस्थापित करता है ।
31	hash.select { |key, value| block } रिटर्न एक नया से कुंजी-मान जोड़ों से मिलकर सरणी हैश जिसके लिए ब्लॉक रिटर्न सच ।
32	hash.shift हैश से एक कुंजी-मूल्य जोड़ी निकालता है , इसे दो-तत्व सरणी के रूप में लौटाता है।
33	hash.size हैश का आकार या लंबाई पूर्णांक के रूप में देता है।
34	hash.sort दो-आयामी सरणी में हैश को कुंजी-मूल्य वाले युग्मों के सरणियों में परिवर्तित करता है , फिर इसे एक सरणी के रूप में क्रमबद्ध करता है।
35	hash.store(key, value) हैश में एक कुंजी-मूल्य जोड़ी संग्रहीत करता है ।
36	hash.to_a हैश से द्वि-आयामी सरणी बनाता है। प्रत्येक कुंजी / मान युग्म को एक सरणी में परिवर्तित किया जाता है, और ये सभी सरणियाँ एक युक्त सरणी में संग्रहीत की जाती हैं।
37	hash.to_hash रिटर्न हैश (स्व)।
38	hash.to_s धर्मान्तरित हैश एक सरणी के लिए है, तो एक स्ट्रिंग के लिए कि सरणी बदल देता है।
39	hash.update(other_hash) [or] hash.update(other_hash) {|key, oldval, newval| block} हैश और अन्य_हाश की सामग्री युक्त एक नया हैश लौटाता है , जो अन्य हैश के साथ डुप्लिकेट कुंजियों के साथ हैश में जोड़े को ओवरराइट करता है ।
40	hash.value?(value) टेस्ट हैश में दिए गए मान शामिल हैं या नहीं ।
41	hash.values हैश के सभी मूल्यों से युक्त एक नई सरणी देता है ।
42	hash.values_at(obj, ...) दिए गए कुंजी या कुंजी के साथ जुड़े हैंश से मूल्यों से युक्त एक नया सरणी लौटाता है ।

Timeरूबी में कक्षा दिनांक और समय का प्रतिनिधित्व करती है। यह ऑपरेटिंग सिस्टम द्वारा प्रदान की गई सिस्टम तिथि और समय की कार्यक्षमता पर एक पतली परत है। यह वर्ग 1970 से पहले या 2038 के बाद की तारीखों का प्रतिनिधित्व करने के लिए आपके सिस्टम पर असमर्थ हो सकता है।

यह अध्याय आपको तारीख और समय के सभी सबसे वांछित अवधारणाओं से परिचित कराता है।

वर्तमान तिथि और समय प्राप्त करना

वर्तमान तिथि और समय प्राप्त करने के लिए सरल उदाहरण निम्नलिखित है -

#!/usr/bin/ruby -w

time1 = Time.new
puts "Current Time : " + time1.inspect

# Time.now is a synonym:
time2 = Time.now
puts "Current Time : " + time2.inspect

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Current Time : Mon Jun 02 12:02:39 -0700 2008
Current Time : Mon Jun 02 12:02:39 -0700 2008

एक तिथि और समय के घटक हो रही है

दिनांक और समय के विभिन्न घटकों को प्राप्त करने के लिए हम समय ऑब्जेक्ट का उपयोग कर सकते हैं । निम्नलिखित उदाहरण वही दिखा रहा है -

#!/usr/bin/ruby -w

time = Time.new

# Components of a Time
puts "Current Time : " + time.inspect
puts time.year    # => Year of the date 
puts time.month   # => Month of the date (1 to 12)
puts time.day     # => Day of the date (1 to 31 )
puts time.wday    # => 0: Day of week: 0 is Sunday
puts time.yday    # => 365: Day of year
puts time.hour    # => 23: 24-hour clock
puts time.min     # => 59
puts time.sec     # => 59
puts time.usec    # => 999999: microseconds
puts time.zone    # => "UTC": timezone name

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Current Time : Mon Jun 02 12:03:08 -0700 2008
2008
6
2
1
154
12
3
8
247476
UTC

Time.utc, Time.gm और Time.local फ़ंक्शंस

इन दो कार्यों का उपयोग मानक प्रारूप में दिनांक को प्रारूपित करने के लिए किया जा सकता है -

# July 8, 2008
Time.local(2008, 7, 8)  
# July 8, 2008, 09:10am, local time
Time.local(2008, 7, 8, 9, 10)   
# July 8, 2008, 09:10 UTC
Time.utc(2008, 7, 8, 9, 10)  
# July 8, 2008, 09:10:11 GMT (same as UTC)
Time.gm(2008, 7, 8, 9, 10, 11)

निम्नलिखित प्रारूप में एक सरणी में सभी घटकों को प्राप्त करने के लिए उदाहरण है -

[sec,min,hour,day,month,year,wday,yday,isdst,zone]

निम्नलिखित प्रयास करें -

#!/usr/bin/ruby -w

time = Time.new
values = time.to_a
p values

यह निम्नलिखित परिणाम उत्पन्न करेगा -

[26, 10, 12, 2, 6, 2008, 1, 154, false, "MST"]

इस सरणी के लिए पारित किया जा सकता है Time.utc या Time.local कार्यों के रूप में निम्नानुसार तारीखों के अलग स्वरूप पाने के लिए -

#!/usr/bin/ruby -w

time = Time.new
values = time.to_a
puts Time.utc(*values)

यह निम्नलिखित परिणाम उत्पन्न करेगा -

Mon Jun 02 12:15:36 UTC 2008

(मंच-निर्भर) युग के बाद से सेकंड के रूप में आंतरिक रूप से समय का प्रतिनिधित्व करने का तरीका निम्नलिखित है -

# Returns number of seconds since epoch
time = Time.now.to_i  

# Convert number of seconds into Time object.
Time.at(time)

# Returns second since epoch which includes microseconds
time = Time.now.to_f

टाइमज़ोन और डेलाइट सेविंग टाइम

आप Timezones और दिन के उजाले बचत से संबंधित सभी जानकारी प्राप्त करने के लिए एक समय वस्तु का उपयोग कर सकते हैं -

time = Time.new

# Here is the interpretation
time.zone       # => "UTC": return the timezone
time.utc_offset # => 0: UTC is 0 seconds offset from UTC
time.zone       # => "PST" (or whatever your timezone is)
time.isdst      # => false: If UTC does not have DST.
time.utc?       # => true: if t is in UTC time zone
time.localtime  # Convert to local timezone.
time.gmtime     # Convert back to UTC.
time.getlocal   # Return a new Time object in local zone
time.getutc     # Return a new Time object in UTC

स्वरूपण टाइम्स और तिथियाँ

दिनांक और समय को प्रारूपित करने के विभिन्न तरीके हैं। यहाँ एक उदाहरण कुछ दिखा रहा है -

#!/usr/bin/ruby -w

time = Time.new
puts time.to_s
puts time.ctime
puts time.localtime
puts time.strftime("%Y-%m-%d %H:%M:%S")

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Mon Jun 02 12:35:19 -0700 2008
Mon Jun  2 12:35:19 2008
Mon Jun 02 12:35:19 -0700 2008
2008-06-02 12:35:19

समय स्वरूपण निर्देश

निम्न तालिका में इन निर्देशों का उपयोग Time.strftime विधि के साथ किया जाता है ।

अनु क्रमांक।	निर्देश और विवरण
1	%a संक्षिप्त सप्ताह का नाम (सूर्य)।
2	%A पूरे सप्ताह का नाम (रविवार)।
3	%b संक्षिप्त माह का नाम (जनवरी)।
4	%B पूरे महीने का नाम (जनवरी)।
5	%c पसंदीदा स्थानीय तिथि और समय प्रतिनिधित्व।
6	%d महीने का दिन (01 से 31)।
7	%H दिन का घंटा, 24 घंटे की घड़ी (00 से 23)।
8	%I दिन का घंटा, 12 घंटे की घड़ी (01 से 12)।
9	%j वर्ष का दिन (001 से 366)।
10	%m वर्ष का महीना (01 से 12)।
1 1	%M प्रति घंटे (00 से 59) मिनट।
12	%p मेरिडियन इंडिकेटर (एएम या पीएम)।
13	%S मिनट का दूसरा (00 से 60)।
14	%U चालू वर्ष की सप्ताह संख्या, पहले सप्ताह के पहले दिन (00 से 53) के रूप में पहले रविवार से शुरू होती है।
15	%W चालू वर्ष की सप्ताह संख्या, पहले सप्ताह के पहले दिन (00 से 53) के रूप में पहले सोमवार से शुरू होती है।
16	%w सप्ताह का दिन (रविवार को 0, 0 से 6 है)।
17	%x अकेले तारीख के लिए पसंदीदा प्रतिनिधित्व, कोई समय नहीं।
18	%X अकेले समय के लिए पसंदीदा प्रतिनिधित्व, कोई तारीख नहीं।
19	%y एक सदी (00 से 99) के बिना वर्ष।
20	%Y शतक के साथ वर्ष।
21	%Z समय क्षेत्र का नाम।
22	%% शाब्दिक% चरित्र।

समय अंकगणित

आप समय के साथ सरल अंकगणित कर सकते हैं -

now = Time.now          # Current time
puts now

past = now - 10         # 10 seconds ago. Time - number => Time
puts past

future = now + 10  # 10 seconds from now Time + number => Time
puts future

diff = future - past     # => 10  Time - Time => number of seconds
puts diff

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Thu Aug 01 20:57:05 -0700 2013
Thu Aug 01 20:56:55 -0700 2013
Thu Aug 01 20:57:15 -0700 2013
20.0

रंग हर जगह होते हैं: जनवरी से दिसंबर, 0 से 9, लाइनें 50 के माध्यम से 67, और इसी तरह। रूबी पर्वतमाला का समर्थन करती है और हमें विभिन्न तरीकों से श्रेणियों का उपयोग करने की अनुमति देती है -

• अनुक्रम के रूप में रंग
• स्थितियों के रूप में
• अंतराल के रूप में रंग

अनुक्रम के रूप में रंग

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

रूबी इन दृश्यों का उपयोग कर बनाता है ''..'' तथा ''...''रेंज ऑपरेटर। दो-डॉट फ़ॉर्म एक समावेशी श्रेणी बनाता है, जबकि तीन-डॉट फ़ॉर्म एक सीमा बनाता है जो निर्दिष्ट उच्च मान को बाहर करता है।

(1..5)        #==> 1, 2, 3, 4, 5
(1...5)       #==> 1, 2, 3, 4
('a'..'d')    #==> 'a', 'b', 'c', 'd'

अनुक्रम 1..100 को दो फिक्सनम ऑब्जेक्ट्स के संदर्भ वाली एक रेंज ऑब्जेक्ट के रूप में आयोजित किया जाता है । यदि आपको आवश्यकता है, तो आप to_a पद्धति का उपयोग करके एक सीमा को सूची में बदल सकते हैं । निम्नलिखित उदाहरण का प्रयास करें -

#!/usr/bin/ruby

$, =", "   # Array value separator
range1 = (1..10).to_a
range2 = ('bar'..'bat').to_a

puts "#{range1}"
puts "#{range2}"

यह निम्नलिखित परिणाम का उत्पादन करेगा -

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
["bar", "bas", "bat"]

रंग उन तरीकों को लागू करते हैं जो आपको उन पर पुनरावृति करते हैं और विभिन्न तरीकों से उनकी सामग्री का परीक्षण करते हैं -

#!/usr/bin/ruby

# Assume a range
digits = 0..9

puts digits.include?(5)
ret = digits.min
puts "Min value is #{ret}"

ret = digits.max
puts "Max value is #{ret}"

ret = digits.reject {|i| i < 5 }
puts "Rejected values are #{ret}"

digits.each do |digit|
   puts "In Loop #{digit}"
end

यह निम्नलिखित परिणाम का उत्पादन करेगा -

true
Min value is 0
Max value is 9
Rejected values are 5, 6, 7, 8, 9
In Loop 0
In Loop 1
In Loop 2
In Loop 3
In Loop 4
In Loop 5
In Loop 6
In Loop 7
In Loop 8
In Loop 9

स्थितियों के रूप में

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

while gets
   print if /start/../end/
end

केस स्टेटमेंट में रंगों का इस्तेमाल किया जा सकता है -

#!/usr/bin/ruby

score = 70

result = case score
   when 0..40 then "Fail"
   when 41..60 then "Pass"
   when 61..70 then "Pass with Merit"
   when 71..100 then "Pass with Distinction"
   else "Invalid Score"
end

puts result

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Pass with Merit

अंतराल के रूप में रंग

बहुमुखी रेंज का एक अंतिम उपयोग अंतराल परीक्षण के रूप में होता है: यह देखते हुए कि क्या रेंज द्वारा दर्शाए गए अंतराल के भीतर कुछ मूल्य गिरता है। यह मामला समानता ऑपरेटर === का उपयोग करके किया जाता है।

#!/usr/bin/ruby

if ((1..10) === 5)
   puts "5 lies in (1..10)"
end

if (('a'..'j') === 'c')
   puts "c lies in ('a'..'j')"
end

if (('a'..'j') === 'z')
   puts "z lies in ('a'..'j')"
end

यह निम्नलिखित परिणाम का उत्पादन करेगा -

5 lies in (1..10)
c lies in ('a'..'j')

Iterators और कुछ नहीं बल्कि संग्रह द्वारा समर्थित विधियां हैं । वे ऑब्जेक्ट जो डेटा सदस्यों के समूह को संग्रहित करते हैं, उन्हें संग्रह कहा जाता है। रूबी में, arrays और hashes को संग्रह कहा जा सकता है।

Iterators संग्रह के सभी तत्वों को एक के बाद एक वापस करते हैं। हम यहां दो पुनरावृत्तियों पर चर्चा करेंगे, प्रत्येक और एकत्रित । आइए इन पर विस्तार से देखें।

प्रत्येक Iterator रूबी

प्रत्येक पुनरावृत्त एक सरणी या हैश के सभी तत्वों को लौटाता है।

वाक्य - विन्यास

collection.each do |variable|
   code
end

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

उदाहरण

#!/usr/bin/ruby

ary = [1,2,3,4,5]
ary.each do |i|
   puts i
end

यह निम्नलिखित परिणाम का उत्पादन करेगा -

1
2
3
4
5

आप हमेशा प्रत्येक पुनरावृत्ति को एक ब्लॉक से जोड़ते हैं। यह एरे के प्रत्येक मान को, एक-एक करके, ब्लॉक में लौटाता है। मान चर में संग्रहीत हैi और फिर स्क्रीन पर प्रदर्शित किया जाता है।

रूबी इकट्ठा इटरेटर

कलेक्ट इटरेटर रिटर्न सब एक संग्रह के तत्वों।

वाक्य - विन्यास

collection = collection.collect

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

उदाहरण

#!/usr/bin/ruby

a = [1,2,3,4,5]
b = Array.new
b = a.collect
puts b

यह निम्नलिखित परिणाम का उत्पादन करेगा -

1
2
3
4
5

NOTE- इकट्ठा विधि सरणियों के बीच नकल करने का सही तरीका नहीं है। एक अन्य विधि है जिसे क्लोन कहा जाता है , जिसका उपयोग एक सरणी को दूसरे सरणी में कॉपी करने के लिए किया जाना चाहिए।

जब आप नया एरे प्राप्त करने के लिए प्रत्येक मान के साथ कुछ करना चाहते हैं तो आप आम तौर पर कलेक्ट पद्धति का उपयोग करते हैं। उदाहरण के लिए, यह कोड एक सरणी बी पैदा करता है जिसमें प्रत्येक में 10 गुना मूल्य होता है ।

#!/usr/bin/ruby

a = [1,2,3,4,5]
b = a.collect{|x| 10*x}
puts b

यह निम्नलिखित परिणाम का उत्पादन करेगा -

10
20
30
40
50

रूबी कर्नेल मॉड्यूल में कार्यान्वित I / O- संबंधित विधियों का एक पूरा सेट प्रदान करता है। सभी I / O विधियां वर्ग IO से ली गई हैं।

कक्षा IO सभी बुनियादी तरीकों को प्रदान करता है, जैसे कि पढ़ना, लिखना, प्राप्त करना, डालता है, पढ़ना, getc, और printf ।

यह अध्याय रूबी में उपलब्ध सभी बुनियादी I / O फ़ंक्शन को कवर करेगा। अधिक कार्यों के लिए, कृपया रूबी क्लास IO देखें ।

पुट स्टेटमेंट

पिछले अध्यायों में, आपने चर के मानों को असाइन किया है और फिर पुट स्टेटमेंट का उपयोग करके आउटपुट प्रिंट किया है ।

पुट बयान चर में संग्रहीत मूल्य प्रदर्शित करने के लिए कार्यक्रम निर्देश देता है। यह प्रत्येक पंक्ति के अंत में एक नई पंक्ति जोड़ देगा जो वह लिखता है।

उदाहरण

#!/usr/bin/ruby

val1 = "This is variable one"
val2 = "This is variable two"
puts val1
puts val2

यह निम्नलिखित परिणाम का उत्पादन करेगा -

This is variable one
This is variable two

स्टेटमेंट मिलता है

हो जाता है बयान STDIN बुलाया मानक स्क्रीन से उपयोगकर्ता से किसी भी इनपुट लेने के लिए इस्तेमाल किया जा सकता।

उदाहरण

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

#!/usr/bin/ruby

puts "Enter a value :"
val = gets
puts val

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Enter a value :
This is entered value
This is entered value

पुट स्टेटमेंट

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

उदाहरण

निम्नलिखित कोड का उत्पादन सिर्फ वर्ण H - है

#!/usr/bin/ruby

str = "Hello Ruby!"
putc str

यह निम्नलिखित परिणाम का उत्पादन करेगा -

H

प्रिंट स्टेटमेंट

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

उदाहरण

#!/usr/bin/ruby

print "Hello World"
print "Good Morning"

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Hello WorldGood Morning

फ़ाइलें खोलना और बंद करना

अब तक, आप मानक इनपुट और आउटपुट को पढ़ते और लिखते रहे हैं। अब, हम देखेंगे कि वास्तविक डेटा फ़ाइलों के साथ कैसे खेलें।

File.new विधि

आप मोड स्ट्रिंग के अनुसार, पढ़ने, लिखने या दोनों के लिए File.new पद्धति का उपयोग करके एक फ़ाइल ऑब्जेक्ट बना सकते हैं । अंत में, आप उस फ़ाइल को बंद करने के लिए File.close पद्धति का उपयोग कर सकते हैं ।

वाक्य - विन्यास

aFile = File.new("filename", "mode")
   # ... process the file
aFile.close

फ़ाइल। विधि

आप एक नई फ़ाइल ऑब्जेक्ट बनाने के लिए File.open पद्धति का उपयोग कर सकते हैं और उस फ़ाइल ऑब्जेक्ट को फ़ाइल में असाइन कर सकते हैं । हालाँकि, File.open और File.new विधियों के बीच एक अंतर है । अंतर यह है कि File.open पद्धति को एक ब्लॉक के साथ जोड़ा जा सकता है, जबकि आप File.new विधि का उपयोग करके ऐसा नहीं कर सकते ।

File.open("filename", "mode") do |aFile|
   # ... process the file
end

यहाँ एक फ़ाइल खोलने के विभिन्न तरीकों की एक सूची है -

अनु क्रमांक।	मोड और विवरण
1	r पढ़ें- केवल मोड फ़ाइल पॉइंटर को फ़ाइल की शुरुआत में रखा जाता है। यह डिफ़ॉल्ट मोड है।
2	r+ पढ़ने-लिखने की विधा। फ़ाइल पॉइंटर फ़ाइल की शुरुआत में होगा।
3	w केवल-मोड लिखें। यदि फ़ाइल मौजूद है, तो फ़ाइल को ओवरराइट करता है। यदि फ़ाइल मौजूद नहीं है, तो लिखने के लिए एक नई फ़ाइल बनाता है।
4	w+ पढ़ने-लिखने की विधा। मौजूदा फ़ाइल को अधिलेखित कर देता है यदि फ़ाइल मौजूद है। यदि फ़ाइल मौजूद नहीं है, तो पढ़ने और लिखने के लिए एक नई फ़ाइल बनाता है।
5	a केवल-मोड लिखें। यदि फ़ाइल मौजूद है, तो फ़ाइल पॉइंटर फ़ाइल के अंत में है। यही है, फ़ाइल एपेंड मोड में है। यदि फ़ाइल मौजूद नहीं है, तो यह लिखने के लिए एक नई फ़ाइल बनाता है।
6	a+ मोड पढ़ें और लिखें। यदि फ़ाइल मौजूद है, तो फ़ाइल पॉइंटर फ़ाइल के अंत में है। फ़ाइल परिशिष्ट मोड में खुलती है। यदि फ़ाइल मौजूद नहीं है, तो यह पढ़ने और लिखने के लिए एक नई फ़ाइल बनाता है।

फाइल पढ़ना और लिखना

वही विधियाँ जो हम 'सरल' I / O के लिए उपयोग कर रहे हैं, सभी फ़ाइल ऑब्जेक्ट के लिए उपलब्ध हैं। तो, मानक इनपुट से एक पंक्ति पढ़ता है, और aFile.gets फ़ाइल ऑब्जेक्ट aFile से एक पंक्ति पढ़ता है।

हालाँकि, I / O ऑब्जेक्ट हमारे जीवन को आसान बनाने के लिए अतिरिक्त तरीकों का सेट प्रदान करता है।

Sysread Method

आप किसी फ़ाइल की सामग्री को पढ़ने के लिए विधि sysread का उपयोग कर सकते हैं । आप किसी भी मोड में फ़ाइल को खोल सकते हैं जब विधि sysread का उपयोग करें। उदाहरण के लिए -

निम्नलिखित इनपुट पाठ फ़ाइल है -

This is a simple text file for testing purpose.

अब इस फाइल को पढ़ने की कोशिश करते हैं -

#!/usr/bin/ruby

aFile = File.new("input.txt", "r")
if aFile
   content = aFile.sysread(20)
   puts content
else
   puts "Unable to open file!"
end

यह कथन फ़ाइल के पहले 20 अक्षरों को आउटपुट करेगा। फ़ाइल पॉइंटर अब फ़ाइल में 21 वें वर्ण पर रखा जाएगा।

Syswrite विधि

आप फ़ाइल में सामग्री लिखने के लिए विधि syswrite का उपयोग कर सकते हैं। विधि syswrite का उपयोग करते समय आपको फ़ाइल को लिखित मोड में खोलने की आवश्यकता है। उदाहरण के लिए -

#!/usr/bin/ruby

aFile = File.new("input.txt", "r+")
if aFile
   aFile.syswrite("ABCDEF")
else
   puts "Unable to open file!"
end

यह कथन फ़ाइल में "ABCDEF" लिखेगा।

प्रत्येक_बाइट विधि

यह तरीका क्लास फाइल का है । विधि प्रत्येक_बाइट हमेशा एक ब्लॉक से जुड़ी होती है। निम्नलिखित कोड नमूने पर विचार करें -

#!/usr/bin/ruby

aFile = File.new("input.txt", "r+")
if aFile
   aFile.syswrite("ABCDEF")
   aFile.each_byte {|ch| putc ch; putc ?. }
else
   puts "Unable to open file!"
end

वर्णों को एक-एक करके चर ch में पास किया जाता है और फिर स्क्रीन पर इस प्रकार प्रदर्शित किया जाता है -

s. .a. .s.i.m.p.l.e. .t.e.x.t. .f.i.l.e. .f.o.r. .t.e.s.t.i.n.g. .p.u.r.p.o.s.e...
.
.

IO.readlines विधि

क्लास फ़ाइल कक्षा IO का उपवर्ग है। कक्षा IO में कुछ विधियां भी हैं, जिनका उपयोग फाइलों में हेरफेर करने के लिए किया जा सकता है।

IO वर्ग विधियों में से एक IO.readlines है । यह विधि फ़ाइल लाइन की सामग्री को लाइन से लौटाती है। निम्न कोड IO.readlines विधि का उपयोग प्रदर्शित करता है -

#!/usr/bin/ruby

arr = IO.readlines("input.txt")
puts arr[0]
puts arr[1]

इस कोड में, चर गिरफ्तारी एक सरणी है। फ़ाइल की प्रत्येक पंक्ति input.txt एरे अरेस्ट में एक एलीमेंट होगी। इसलिए, गिरफ्तारी [0] में पहली पंक्ति होगी, जबकि गिरफ्तारी [1] में फ़ाइल की दूसरी पंक्ति होगी।

IO.foreach विधि

यह विधि आउटपुट लाइन को लाइन द्वारा भी लौटाती है। विधि foreach और विधि readlines के बीच अंतर यह है कि विधि foreach एक ब्लॉक के साथ जुड़ा हुआ है। हालाँकि, विधि रीडलाइन के विपरीत , विधि foreach एक सरणी नहीं लौटाती है । उदाहरण के लिए -

#!/usr/bin/ruby

IO.foreach("input.txt"){|block| puts block}

यह कोड फ़ाइल परीक्षण लाइन की सामग्री को चर ब्लॉक के लिए लाइन से पारित करेगा , और फिर आउटपुट स्क्रीन पर प्रदर्शित किया जाएगा।

फ़ाइलों का नाम बदलना और हटाना

आप नाम बदलने और हटाने के तरीकों के साथ रूबी के साथ प्रोग्रामेटिक रूप से फ़ाइलों का नाम बदल सकते हैं और हटा सकते हैं ।

एक मौजूदा फ़ाइल test1.txt का नाम बदलने के लिए निम्नलिखित उदाहरण है -

#!/usr/bin/ruby

# Rename a file from test1.txt to test2.txt
File.rename( "test1.txt", "test2.txt" )

मौजूदा फ़ाइल test2.txt को हटाने के लिए उदाहरण निम्नलिखित है -

#!/usr/bin/ruby

# Delete file test2.txt
File.delete("test2.txt")

फ़ाइल मोड और स्वामित्व

किसी फ़ाइल के मोड या अनुमतियाँ / पहुँच सूची को बदलने के लिए मास्क के साथ chmod विधि का उपयोग करें -

निम्न उदाहरण किसी मौजूदा फ़ाइल के मोड बदलने के लिए है test.txt एक मुखौटा मूल्य के लिए -

#!/usr/bin/ruby

file = File.new( "test.txt", "w" )
file.chmod( 0755 )

निम्नलिखित तालिका है, जो आपको chmod विधि के लिए विभिन्न मास्क चुनने में मदद कर सकती है -

अनु क्रमांक।	मुखौटा और विवरण
1	0700 मालिक के लिए rwx मास्क
2	0400 मालिक के लिए आर
3	0200 मालिक के लिए डब्ल्यू
4	0100 मालिक के लिए एक्स
5	0070 समूह के लिए rwx मास्क
6	0040 समूह के लिए आर
7	0020 समूह के लिए डब्ल्यू
8	0010 समूह के लिए एक्स
9	0007 अन्य के लिए rwx मास्क
10	0004 अन्य के लिए आर
1 1	0002 w दूसरे के लिए
12	0001 अन्य के लिए एक्स
13	4000 निष्पादन पर उपयोगकर्ता आईडी सेट करें
14	2000 निष्पादन पर समूह आईडी सेट करें
15	1000 उपयोग के बाद भी स्वैप किए गए पाठ को सहेजें

फ़ाइल पूछताछ

निम्न कमांड परीक्षण करता है कि क्या फ़ाइल खोलने से पहले मौजूद है -

#!/usr/bin/ruby

File.open("file.rb") if File::exists?( "file.rb" )

निम्न कमांड पूछताछ करती है कि क्या फाइल वास्तव में एक फाइल है -

#!/usr/bin/ruby

# This returns either true or false
File.file?( "text.txt" )

निम्न कमांड यह पता लगाती है कि क्या दिया गया फ़ाइल नाम एक निर्देशिका है -

#!/usr/bin/ruby

# a directory
File::directory?( "/usr/local/bin" ) # => true

# a file
File::directory?( "file.rb" ) # => false

निम्न कमांड पाता है कि क्या फ़ाइल पठनीय, लिखने योग्य या निष्पादन योग्य है -

#!/usr/bin/ruby

File.readable?( "test.txt" )   # => true
File.writable?( "test.txt" )   # => true
File.executable?( "test.txt" ) # => false

निम्न कमांड पाता है कि फ़ाइल में शून्य आकार है या नहीं -

#!/usr/bin/ruby

File.zero?( "test.txt" )      # => true

निम्न आदेश फ़ाइल का आकार देता है -

#!/usr/bin/ruby

File.size?( "text.txt" )     # => 1002

निम्न कमांड का उपयोग एक प्रकार की फ़ाइल का पता लगाने के लिए किया जा सकता है -

#!/usr/bin/ruby

File::ftype( "test.txt" )     # => file

Ftype विधि निम्न में से किसी एक को वापस करके फ़ाइल के प्रकार की पहचान करती है - फ़ाइल, निर्देशिका, characterSpecial, blockSpecial, फीफो, लिंक, सॉकेट, या अज्ञात।

जब फ़ाइल बनाई गई, संशोधित की गई हो या अंतिम एक्सेस की गई हो, तो निम्न कमांड का उपयोग किया जा सकता है -

#!/usr/bin/ruby

File::ctime( "test.txt" ) # => Fri May 09 10:06:37 -0700 2008
File::mtime( "text.txt" ) # => Fri May 09 10:44:44 -0700 2008
File::atime( "text.txt" ) # => Fri May 09 10:45:01 -0700 2008

रूबी में निर्देशिकाएँ

सभी फाइलें विभिन्न निर्देशिकाओं में निहित हैं, और रूबी को इनसे निपटने में कोई समस्या नहीं है। जबकि फ़ाइल वर्ग फ़ाइलों को संभालता है, निर्देशिका को Dir वर्ग के साथ संभाला जाता है ।

निर्देशिकाओं के माध्यम से नेविगेट करना

रूबी प्रोग्राम के भीतर डायरेक्टरी बदलने के लिए, Dir.chdir का उपयोग इस प्रकार करें। यह उदाहरण वर्तमान निर्देशिका को / usr / bin में बदलता है ।

Dir.chdir("/usr/bin")

आप जान सकते हैं कि वर्तमान निर्देशिका Dir.pwd के साथ क्या है -

puts Dir.pwd # This will return something like /usr/bin

आप Dir.entries का उपयोग करके एक विशेष निर्देशिका के भीतर फ़ाइलों और निर्देशिकाओं की एक सूची प्राप्त कर सकते हैं -

puts Dir.entries("/usr/bin").join(' ')

Dir.entries निर्दिष्ट निर्देशिका के भीतर सभी प्रविष्टियों के साथ एक सरणी देता है। Dir.foreach एक ही सुविधा प्रदान करता है -

Dir.foreach("/usr/bin") do |entry|
   puts entry
end

डायरेक्ट्री लिस्टिंग प्राप्त करने का एक और अधिक संक्षिप्त तरीका है, Dir's क्लास एरे विधि का उपयोग करके -

Dir["/usr/bin/*"]

एक निर्देशिका बनाना

Dir.mkdir निर्देशिका बनाने के लिए इस्तेमाल किया जा सकता है -

Dir.mkdir("mynewdir")

आप mkdir के साथ एक नई निर्देशिका (पहले से मौजूद नहीं है) पर अनुमतियाँ सेट कर सकते हैं -

NOTE - मास्क 755 सेट अनुमतियों के मालिक, समूह, दुनिया [किसी को भी] rwxr-xr-x जहां r = पढ़ा, w = लिखना, और x = निष्पादित करता है।

Dir.mkdir( "mynewdir", 755 )

एक निर्देशिका को हटाना

Dir.delete एक निर्देशिका नष्ट करने के लिए इस्तेमाल किया जा सकता। Dir.unlink और Dir.rmdir प्रदर्शन ठीक उसी समारोह और सुविधा के लिए प्रदान की जाती हैं।

Dir.delete("testdir")

फ़ाइलें और अस्थायी निर्देशिका बनाना

अस्थाई फाइलें वे हैं जो किसी प्रोग्राम के निष्पादन के दौरान संक्षिप्त रूप से बनाई जा सकती हैं, लेकिन जानकारी का एक स्थायी स्टोर नहीं हैं।

Dir.tmpdir वर्तमान प्रणाली पर अस्थायी निर्देशिका को पथ प्रदान करता है, हालांकि विधि डिफ़ॉल्ट रूप से उपलब्ध नहीं है। Dir.tmpdir को उपलब्ध कराने के लिए 'tmpdir' की आवश्यकता होती है।

आप एक प्लेटफ़ॉर्म-स्वतंत्र अस्थायी फ़ाइल बनाने के लिए File.join के साथ Dir.tmpdir का उपयोग कर सकते हैं -

require 'tmpdir'
   tempfilename = File.join(Dir.tmpdir, "tingtong")
   tempfile = File.new(tempfilename, "w")
   tempfile.puts "This is a temporary file"
   tempfile.close
   File.delete(tempfilename)

यह कोड एक अस्थायी फ़ाइल बनाता है, इसे डेटा लिखता है, और इसे हटाता है। रूबी की मानक लाइब्रेरी में टेम्पेफाइल नामक एक पुस्तकालय भी शामिल है जो आपके लिए अस्थायी फाइलें बना सकता है -

require 'tempfile'
   f = Tempfile.new('tingtong')
   f.puts "Hello"
   puts f.path
   f.close

अंतर्निहित कार्य

यहाँ फ़ाइलों और निर्देशिकाओं को संसाधित करने के लिए रूबी निर्मित कार्य हैं -

• फाइल क्लास और तरीके ।

• Dir क्लास और तरीके ।

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

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

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

वाक्य - विन्यास

begin  
# -  
rescue OneTypeOfException  
# -  
rescue AnotherTypeOfException  
# -  
else  
# Other exceptions
ensure
# Always will be executed
end

शुरू से बचाव तक सब कुछ संरक्षित है। यदि कोड के इस ब्लॉक के निष्पादन के दौरान कोई अपवाद होता है, तो नियंत्रण बचाव और अंत के बीच के ब्लॉक में जाता है ।

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

इस घटना में कि कोई अपवाद निर्दिष्ट किसी भी प्रकार की त्रुटि से मेल नहीं खाता है, हमें सभी बचाव खंडों के बाद किसी अन्य खंड का उपयोग करने की अनुमति है ।

उदाहरण

#!/usr/bin/ruby

begin
   file = open("/unexistant_file")
   if file
      puts "File opened successfully"
   end
rescue
      file = STDIN
end
print file, "==", STDIN, "\n"

यह निम्नलिखित परिणाम का उत्पादन करेगा। आप देख सकते हैं कि एसटीडीआईएन फाइल करने के लिए प्रतिस्थापित किया गया है क्योंकि ओपन फेल है।

#<IO:0xb7d16f84>==#<IO:0xb7d16f84>

रिट्री स्टेटमेंट का उपयोग करना

आप बचाव ब्लॉक का उपयोग करके एक अपवाद पर कब्जा कर सकते हैं और फिर शुरू से ब्लॉक शुरू करने के लिए पुन: प्रयास विवरण का उपयोग कर सकते हैं ।

वाक्य - विन्यास

begin
   # Exceptions raised by this code will 
   # be caught by the following rescue clause
rescue
   # This block will capture all types of exceptions
   retry  # This will move control to the beginning of begin
end

उदाहरण

#!/usr/bin/ruby

begin
   file = open("/unexistant_file")
   if file
      puts "File opened successfully"
   end
rescue
   fname = "existant_file"
   retry
end

निम्नलिखित प्रक्रिया का प्रवाह है -

• एक अपवाद खुला हुआ।
• बचाव के लिए गया। fname फिर से सौंपा गया था।
• रिट्री द्वारा शुरुआत की शुरुआत में चला गया।
• यह समय फ़ाइल सफलतापूर्वक खुलती है।
• आवश्यक प्रक्रिया जारी रखी।

NOTE- ध्यान दें कि यदि पुन: प्रतिस्थापित नाम की फाइल मौजूद नहीं है, तो यह उदाहरण कोड असीम रूप से पुनर्प्रयास करता है। यदि आप अपवाद प्रक्रिया के लिए पुनः प्रयास का उपयोग करते हैं तो सावधान रहें ।

उठाना स्टेटमेंट का उपयोग करना

आप एक अपवाद को बढ़ाने के लिए स्टेटमेंट का उपयोग कर सकते हैं । जब भी यह कहा जाता है निम्नलिखित विधि एक अपवाद उठाती है। यह दूसरा संदेश छपा होगा।

वाक्य - विन्यास

raise 

OR

raise "Error Message" 

OR

raise ExceptionType, "Error Message"

OR

raise ExceptionType, "Error Message" condition

पहला रूप केवल वर्तमान अपवाद (या कोई वर्तमान अपवाद नहीं है, तो एक रंटइमार्ट) को फिर से उठाता है। इसका उपयोग अपवाद संचालकों में किया जाता है जिन्हें इसे पारित करने से पहले अपवाद को रोकना पड़ता है।

दूसरा रूप एक नया RuntimeError अपवाद बनाता है, इसके संदेश को दिए गए स्ट्रिंग में सेट करता है। यह अपवाद तब कॉल स्टैक उठाया जाता है।

तीसरा फ़ॉर्म अपवाद बनाने के लिए पहले तर्क का उपयोग करता है और फिर संबंधित संदेश को दूसरे तर्क पर सेट करता है।

चौथा रूप तीसरे रूप के समान है लेकिन आप कोई भी सशर्त विवरण जोड़ सकते हैं जब तक कि कोई अपवाद न उठाया जाए ।

उदाहरण

#!/usr/bin/ruby

begin  
   puts 'I am before the raise.'  
   raise 'An error has occurred.'  
   puts 'I am after the raise.'  
rescue  
   puts 'I am rescued.'  
end  
puts 'I am after the begin block.'

यह निम्नलिखित परिणाम का उत्पादन करेगा -

I am before the raise.  
I am rescued.  
I am after the begin block.

एक और उदाहरण जो उठाने के उपयोग को दर्शाता है -

#!/usr/bin/ruby

begin  
   raise 'A test exception.'  
rescue Exception => e  
   puts e.message  
   puts e.backtrace.inspect  
end

यह निम्नलिखित परिणाम का उत्पादन करेगा -

A test exception.
["main.rb:4"]

सुनिश्चित कथन का उपयोग करना

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

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

वाक्य - विन्यास

begin 
   #.. process 
   #..raise exception
rescue 
   #.. handle error 
ensure 
   #.. finally ensure execution
   #.. This will always execute.
end

उदाहरण

begin
   raise 'A test exception.'
rescue Exception => e
   puts e.message
   puts e.backtrace.inspect
ensure
   puts "Ensuring execution"
end

यह निम्नलिखित परिणाम का उत्पादन करेगा -

A test exception.
["main.rb:4"]
Ensuring execution

कथन का उपयोग करना

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

कोड के मुख्य निकाय द्वारा कोई अपवाद नहीं उठाए जाने पर ही किसी अन्य खंड के निकाय को निष्पादित किया जाता है।

वाक्य - विन्यास

begin 
   #.. process 
   #..raise exception
rescue 
   # .. handle error
else
   #.. executes if there is no exception
ensure 
   #.. finally ensure execution
   #.. This will always execute.
end

उदाहरण

begin
   # raise 'A test exception.'
   puts "I'm not raising exception"
rescue Exception => e
   puts e.message
   puts e.backtrace.inspect
else
   puts "Congratulations-- no errors!"
ensure
   puts "Ensuring execution"
end

यह निम्नलिखित परिणाम का उत्पादन करेगा -

I'm not raising exception
Congratulations-- no errors!
Ensuring execution

उठाया त्रुटि संदेश $ का उपयोग करके कब्जा किया जा सकता है! चर।

कैच एंड थ्रो

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

पकड़ एक ब्लॉक है कि व्यक्ति का नाम (जो एक प्रतीक या एक स्ट्रिंग हो सकता है) के साथ लेबल है परिभाषित करता है। ब्लॉक को सामान्य रूप से तब तक निष्पादित किया जाता है जब तक कि एक थ्रो का सामना नहीं किया जाता है।

वाक्य - विन्यास

throw :lablename
#.. this will not be executed
catch :lablename do
#.. matching catch will be executed after a throw is encountered.
end

OR

throw :lablename condition
#.. this will not be executed
catch :lablename do
#.. matching catch will be executed after a throw is encountered.
end

उदाहरण

निम्न उदाहरण उपयोगकर्ता के साथ बातचीत को समाप्त करने के लिए थ्रो का उपयोग करता है यदि '!' किसी भी संकेत के जवाब में टाइप किया गया है।

def promptAndGet(prompt)
   print prompt
   res = readline.chomp
   throw :quitRequested if res == "!"
   return res
end

catch :quitRequested do
   name = promptAndGet("Name: ")
   age = promptAndGet("Age: ")
   sex = promptAndGet("Sex: ")
   # ..
   # process information
end
promptAndGet("Name:")

आपको अपने मशीन पर उपरोक्त कार्यक्रम की कोशिश करनी चाहिए क्योंकि इसे मैन्युअल इंटरैक्शन की आवश्यकता है। यह निम्नलिखित परिणाम का उत्पादन करेगा -

Name: Ruby on Rails
Age: 3
Sex: !
Name:Just Ruby

कक्षा का अपवाद

रूबी के मानक वर्ग और मॉड्यूल अपवादों को बढ़ाते हैं। सभी अपवाद वर्ग शीर्ष पर वर्ग अपवाद के साथ एक पदानुक्रम बनाते हैं। अगले स्तर में सात अलग-अलग प्रकार हैं -

• Interrupt
• NoMemoryError
• SignalException
• ScriptError
• StandardError
• SystemExit

इस स्तर पर एक अन्य अपवाद है, Fatal, लेकिन रूबी दुभाषिया केवल आंतरिक रूप से इसका उपयोग करता है।

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

आइए एक उदाहरण देखें -

class FileSaveError < StandardError
   attr_reader :reason
   def initialize(reason)
      @reason = reason
   end
end

अब, निम्नलिखित उदाहरण को देखें, जो इस अपवाद का उपयोग करेगा -

File.open(path, "w") do |file|
begin
   # Write out the data ...
rescue
   # Something went wrong!
   raise FileSaveError.new($!)
end
end

यहाँ महत्वपूर्ण लाइन FileSaveError.new ($!) है । हम कॉल करने के लिए संकेत देते हैं कि एक अपवाद उत्पन्न हुआ है, इसे फाइलशेयर के एक नए उदाहरण से गुजरते हुए, इस कारण से कि विशिष्ट अपवाद के कारण डेटा का लेखन विफल हो गया।

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

किसी ऑब्जेक्ट के रूप को निर्दिष्ट करने के लिए एक वर्ग का उपयोग किया जाता है और यह उस डेटा को एक साफ पैकेज में हेरफेर करने के लिए डेटा प्रतिनिधित्व और विधियों को जोड़ता है। किसी वर्ग के भीतर के डेटा और विधियों को कक्षा के सदस्य कहा जाता है।

रूबी क्लास परिभाषा

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

कीवर्ड के साथ एक वर्ग परिभाषा शुरू होती है class इसके बाद class name और एक के साथ सीमांकित है end। उदाहरण के लिए, हमने बॉक्स क्लास को कीवर्ड क्लास का उपयोग करते हुए परिभाषित किया है -

class Box
   code
end

नाम को एक कैपिटल लेटर से शुरू करना चाहिए और कन्वेंशन के नाम जिसमें एक से अधिक शब्द होते हैं, को एक-एक शब्द के साथ-साथ चलाया जाता है और कोई अलग अक्षर (CamelCase) नहीं होता है।

रूबी वस्तुओं को परिभाषित करें

एक वर्ग वस्तुओं के लिए ब्लूप्रिंट प्रदान करता है, इसलिए मूल रूप से एक वर्ग से एक वस्तु बनाई जाती है। हम एक वर्ग की वस्तुओं की घोषणा करते हैंnewकीवर्ड। निम्नलिखित कथन कक्षा बॉक्स की दो वस्तुओं की घोषणा करते हैं -

box1 = Box.new
box2 = Box.new

प्रारंभिक विधि

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

class Box
   def initialize(w,h)
      @width, @height = w, h
   end
end

चर चर

instance variablesएक तरह के वर्ग गुण होते हैं और वे वस्तुओं के गुण बन जाते हैं जब एक बार कक्षा का उपयोग करके वस्तुएँ बनाई जाती हैं। प्रत्येक ऑब्जेक्ट की विशेषताओं को व्यक्तिगत रूप से सौंपा गया है और अन्य वस्तुओं के साथ कोई मूल्य साझा नहीं करता है। उन्हें कक्षा के भीतर @ ऑपरेटर का उपयोग करके एक्सेस किया जाता है लेकिन हम जिस कक्षा का उपयोग करते हैं, उसके बाहर उन्हें एक्सेस करने के लिएpublic विधियाँ, जिन्हें कहा जाता है accessor methods। यदि हम उपरोक्त परिभाषित वर्ग लेते हैंBox तब @ Recharge और @height क्लास बॉक्स के लिए उदाहरण चर हैं।

class Box
   def initialize(w,h)
      # assign instance variables
      @width, @height = w, h
   end
end

एक्सेसर और सेटर मेथड्स

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

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end

   # accessor methods
   def printWidth
      @width
   end

   def printHeight
      @height
   end
end

# create an object
box = Box.new(10, 20)

# use accessor methods
x = box.printWidth()
y = box.printHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

जब उपरोक्त कोड निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है -

Width of the box is : 10
Height of the box is : 20

एक्सेसर विधियों के समान, जिनका उपयोग चर के मूल्य तक पहुंचने के लिए किया जाता है, रूबी कक्षा के बाहर से उन चर के मूल्यों को निर्धारित करने का एक तरीका प्रदान करता है setter methods, जो नीचे के रूप में परिभाषित किए गए हैं -

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end

   # accessor methods
   def getWidth
      @width
   end
   def getHeight
      @height
   end

   # setter methods
   def setWidth=(value)
      @width = value
   end
   def setHeight=(value)
      @height = value
   end
end

# create an object
box = Box.new(10, 20)

# use setter methods
box.setWidth = 30
box.setHeight = 50

# use accessor methods
x = box.getWidth()
y = box.getHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

जब उपरोक्त कोड निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है -

Width of the box is : 30
Height of the box is : 50

उदाहरण के तरीके

instance methods हम उसी तरह से परिभाषित होते हैं जैसे हम किसी अन्य विधि का उपयोग करके परिभाषित करते हैं defकीवर्ड और उन्हें क्लास उदाहरण का उपयोग करके केवल नीचे दिखाए अनुसार उपयोग किया जा सकता है। उनकी कार्यक्षमता उदाहरण चर तक पहुँचने के लिए सीमित नहीं है, लेकिन यह भी वे अपनी आवश्यकता के अनुसार बहुत अधिक कर सकते हैं।

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end
   # instance method
   def getArea
      @width * @height
   end
end

# create an object
box = Box.new(10, 20)

# call instance methods
a = box.getArea()
puts "Area of the box is : #{a}"

जब उपरोक्त कोड निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है -

Area of the box is : 200

कक्षा के तरीके और चर

class variablesएक चर है, जो एक वर्ग के सभी उदाहरणों के बीच साझा किया जाता है। दूसरे शब्दों में, चर का एक उदाहरण है और इसे ऑब्जेक्ट इंस्टेंस द्वारा एक्सेस किया जाता है। वर्ग चर दो @ वर्ण (@@) के साथ उपसर्ग किए जाते हैं। एक वर्ग चर को वर्ग परिभाषा के भीतर आरंभीकृत किया जाना चाहिए जैसा कि नीचे दिखाया गया है।

एक वर्ग विधि का उपयोग करके परिभाषित किया गया है def self.methodname(), जो अंत परिसीमन के साथ समाप्त होता है और वर्ग नाम का उपयोग करके बुलाया जाएगा classname.methodname जैसा कि निम्नलिखित उदाहरण में दिखाया गया है -

#!/usr/bin/ruby -w

class Box
   # Initialize our class variables
   @@count = 0
   def initialize(w,h)
      # assign instance avriables
      @width, @height = w, h

      @@count += 1
   end

   def self.printCount()
      puts "Box count is : #@@count"
   end
end

# create two object
box1 = Box.new(10, 20)
box2 = Box.new(30, 100)

# call class method to print box count
Box.printCount()

जब उपरोक्त कोड निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है -

Box count is : 2

To_s विधि

आपके द्वारा परिभाषित किसी भी वर्ग में एक होना चाहिए to_sवस्तु की एक स्ट्रिंग प्रतिनिधित्व वापस करने के लिए उदाहरण विधि। चौड़ाई और ऊंचाई के संदर्भ में एक बॉक्स ऑब्जेक्ट का प्रतिनिधित्व करने के लिए एक सरल उदाहरण निम्नलिखित है -

#!/usr/bin/ruby -w

class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end
   # define to_s method
   def to_s
      "(w:#@width,h:#@height)"  # string formatting of the object.
   end
end

# create an object
box = Box.new(10, 20)

# to_s method will be called in reference of string automatically.
puts "String representation of box is : #{box}"

जब उपरोक्त कोड निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है -

String representation of box is : (w:10,h:20)

पहुँच नियंत्रण

रूबी आपको उदाहरण के स्तर के स्तर पर सुरक्षा के तीन स्तर देता है, जो हो सकता है public, private, or protected। रूबी उदाहरण और वर्ग चर पर कोई अभिगम नियंत्रण लागू नहीं करती है।

• Public Methods- सार्वजनिक तरीकों से किसी को भी बुलाया जा सकता है। प्रारंभिक रूप को छोड़कर, विधि डिफ़ॉल्ट रूप से सार्वजनिक होती है, जो हमेशा निजी होती है।

• Private Methods- निजी तरीकों को एक्सेस नहीं किया जा सकता है, या क्लास के बाहर से भी देखा जा सकता है। केवल कक्षा के तरीके निजी सदस्यों तक पहुंच सकते हैं।

• Protected Methods- एक संरक्षित पद्धति को केवल परिभाषित वर्ग और उसके उपवर्गों की वस्तुओं द्वारा ही लागू किया जा सकता है। परिवार के भीतर पहुंच रखी जाती है।

तीनों पहुँच संशोधक के वाक्य विन्यास को दिखाने के लिए एक सरल उदाहरण निम्नलिखित है -

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end

   # instance method by default it is public
   def getArea
      getWidth() * getHeight
   end

   # define private accessor methods
   def getWidth
      @width
   end
   def getHeight
      @height
   end
   # make them private
   private :getWidth, :getHeight

   # instance method to print area
   def printArea
      @area = getWidth() * getHeight
      puts "Big box area is : #@area"
   end
   # make it protected
   protected :printArea
end

# create an object
box = Box.new(10, 20)

# call instance methods
a = box.getArea()
puts "Area of the box is : #{a}"

# try to call protected or methods
box.printArea()

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

Area of the box is : 200
test.rb:42: protected method `printArea' called for #
<Box:0xb7f11280 @height = 20, @width = 10> (NoMethodError)

कक्षा में प्रवेश

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

वंशानुक्रम भी कोड कार्यक्षमता और तेजी से कार्यान्वयन के समय का पुन: उपयोग करने का अवसर प्रदान करता है लेकिन दुर्भाग्य से रूबी विरासत के कई स्तरों का समर्थन नहीं करता है लेकिन रूबी का समर्थन करता है mixins। एक मिक्सिन मल्टीपल इनहेरिटेंस के एक विशेष कार्यान्वयन की तरह है जिसमें केवल इंटरफ़ेस भाग विरासत में मिला है।

क्लास बनाते समय, पूरी तरह से नए डेटा सदस्यों और सदस्य कार्यों को लिखने के बजाय, प्रोग्रामर यह नामित कर सकता है कि नए वर्ग को किसी मौजूदा क्लास के सदस्यों को विरासत में प्राप्त करना चाहिए। इस मौजूदा वर्ग को कहा जाता हैbase class or superclass, और नई कक्षा को इस रूप में संदर्भित किया जाता है derived class or sub-class।

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

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end
   # instance method
   def getArea
      @width * @height
   end
end

# define a subclass
class BigBox < Box

   # add a new instance method
   def printArea
      @area = @width * @height
      puts "Big box area is : #@area"
   end
end

# create an object
box = BigBox.new(10, 20)

# print the area
box.printArea()

जब उपरोक्त कोड निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है -

Big box area is : 200

तरीके ओवरराइडिंग

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

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end
   # instance method
   def getArea
      @width * @height
   end
end

# define a subclass
class BigBox < Box

   # change existing getArea method as follows
   def getArea
      @area = @width * @height
      puts "Big box area is : #@area"
   end
end

# create an object
box = BigBox.new(10, 20)

# print the area using overriden method.
box.getArea()

ऑपरेटर ओवरलोडिंग

हम + ऑपरेटर का उपयोग करके दो बॉक्स ऑब्जेक्ट्स के वेक्टर जोड़ के प्रदर्शन के लिए +, * ऑपरेटर को एक बॉक्स चौड़ाई और ऊंचाई को स्केलर द्वारा गुणा करने के लिए, और एकरी - ऑपरेटर बॉक्स की चौड़ाई और ऊंचाई को नकारने के लिए चाहेंगे। यहाँ परिभाषित गणितीय ऑपरेटरों के साथ बॉक्स वर्ग का एक संस्करण है -

class Box
   def initialize(w,h)     # Initialize the width and height
      @width,@height = w, h
   end

   def +(other)       # Define + to do vector addition
      Box.new(@width + other.width, @height + other.height)
   end

   def -@           # Define unary minus to negate width and height
      Box.new(-@width, -@height)
   end

   def *(scalar)           # To perform scalar multiplication
      Box.new(@width*scalar, @height*scalar)
   end
end

बर्फ़ीली वस्तुएँ

कभी-कभी, हम किसी ऑब्जेक्ट को परिवर्तित होने से रोकना चाहते हैं। ऑब्जेक्ट में फ्रीज विधि हमें ऐसा करने की अनुमति देती है, प्रभावी रूप से एक वस्तु को स्थिर में बदल देती है। किसी भी वस्तु को तपाने से जम सकता हैObject.freeze। एक जमे हुए ऑब्जेक्ट को संशोधित नहीं किया जा सकता है: आप इसके उदाहरण चर नहीं बदल सकते।

आप जांच सकते हैं कि कोई दी गई वस्तु पहले से जमी हुई है या नहीं Object.frozen?विधि, जो वस्तु के जम जाने पर सही हो जाती है अन्यथा एक गलत मान वापस आ जाता है। निम्नलिखित उदाहरण अवधारणा को साफ करता है -

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end

   # accessor methods
   def getWidth
      @width
   end
   def getHeight
      @height
   end

   # setter methods
   def setWidth=(value)
      @width = value
   end
   def setHeight=(value)
      @height = value
   end
end

# create an object
box = Box.new(10, 20)

# let us freez this object
box.freeze
if( box.frozen? )
   puts "Box object is frozen object"
else
   puts "Box object is normal object"
end

# now try using setter methods
box.setWidth = 30
box.setHeight = 50

# use accessor methods
x = box.getWidth()
y = box.getHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

जब उपरोक्त कोड निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है -

Box object is frozen object
test.rb:20:in `setWidth=': can't modify frozen object (TypeError)
   from test.rb:39

क्लास कांस्टेंट

आप एक चर के लिए एक प्रत्यक्ष संख्यात्मक या स्ट्रिंग मान निर्दिष्ट करके एक वर्ग के अंदर एक निरंतर परिभाषित कर सकते हैं, जो कि @ या @@ का उपयोग किए बिना परिभाषित किया गया है। अधिवेशन के द्वारा, हम ऊपरी मामले में निरंतर नाम रखते हैं।

एक बार एक स्थिरांक परिभाषित हो जाने के बाद, आप इसका मान नहीं बदल सकते हैं लेकिन आप किसी वर्ग जैसे चर के अंदर एक निरंतर का उपयोग कर सकते हैं लेकिन यदि आप कक्षा के बाहर किसी स्थिरांक तक पहुँचना चाहते हैं तो आपको इसका उपयोग करना होगा classname::constant जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है।

#!/usr/bin/ruby -w

# define a class
class Box
   BOX_COMPANY = "TATA Inc"
   BOXWEIGHT = 10
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end
   # instance method
   def getArea
      @width * @height
   end
end

# create an object
box = Box.new(10, 20)

# call instance methods
a = box.getArea()
puts "Area of the box is : #{a}"
puts Box::BOX_COMPANY
puts "Box weight is: #{Box::BOXWEIGHT}"

जब उपरोक्त कोड निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है -

Area of the box is : 200
TATA Inc
Box weight is: 10

क्लास के स्थिरांक विरासत में मिले हैं और उदाहरण के तरीकों की तरह इसे ओवरराइड किया जा सकता है।

एलाट का उपयोग करके ऑब्जेक्ट बनाएं

ऐसी स्थिति हो सकती है जब आप किसी वस्तु को उसके निर्माता को बुलाए बिना बनाना चाहते हैं initializeअर्थात नई विधि का उपयोग करते हुए, ऐसे मामले में आप आवंटन को कॉल कर सकते हैं , जो आपके लिए एक असंगठित वस्तु बनाएगा जैसा कि निम्नलिखित उदाहरण में है -

#!/usr/bin/ruby -w

# define a class
class Box
   attr_accessor :width, :height

   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end

   # instance method
   def getArea
      @width * @height
   end
end

# create an object using new
box1 = Box.new(10, 20)

# create another object using allocate
box2 = Box.allocate

# call instance method using box1
a = box1.getArea()
puts "Area of the box is : #{a}"

# call instance method using box2
a = box2.getArea()
puts "Area of the box is : #{a}"

जब उपरोक्त कोड निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है -

Area of the box is : 200
test.rb:14: warning: instance variable @width not initialized
test.rb:14: warning: instance variable @height not initialized
test.rb:14:in `getArea': undefined method `*' 
   for nil:NilClass (NoMethodError) from test.rb:29

कक्षा की जानकारी

यदि कक्षा की परिभाषाएं निष्पादन योग्य कोड हैं, तो इसका मतलब है कि वे किसी वस्तु के संदर्भ में निष्पादित करते हैं: स्वयं को कुछ का संदर्भ देना चाहिए। आइए जानें कि यह क्या है।

#!/usr/bin/ruby -w

class Box
   # print class information
   puts "Type of self = #{self.type}"
   puts "Name of self = #{self.name}"
end

जब उपरोक्त कोड निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है -

Type of self = Class
Name of self = Box

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

एक नियमित अभिव्यक्ति वर्णों का एक विशेष अनुक्रम है जो आपको एक पैटर्न में रखे गए विशेष सिंटैक्स का उपयोग करके तार के अन्य तारों या सेटों को मिलाने या खोजने में मदद करता है।

एक नियमित अभिव्यक्ति शाब्दिक स्लैश के बीच या मनमाने ढंग से परिसीमन के बीच एक पैटर्न है, जिसके बाद% r निम्नानुसार है -

वाक्य - विन्यास

/pattern/
/pattern/im    # option can be specified
%r!/usr/local! # general delimited regular expression

उदाहरण

#!/usr/bin/ruby

line1 = "Cats are smarter than dogs";
line2 = "Dogs also like meat";

if ( line1 =~ /Cats(.*)/ )
   puts "Line1 contains Cats"
end
if ( line2 =~ /Cats(.*)/ )
   puts "Line2 contains  Dogs"
end

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Line1 contains Cats

रेगुलर-एक्सप्रेशन मॉडिफायर्स

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

अनु क्रमांक।	संशोधक और विवरण
1	i पाठ से मेल खाते समय मामले पर ध्यान नहीं देता।
2	o # {} केवल एक बार प्रक्षेप करता है, पहली बार रेगेक्सप शाब्दिक मूल्यांकन किया जाता है।
3	x व्हाट्सएप को इग्नोर करता है और रेगुलर एक्सप्रेशन में कमेंट्स की अनुमति देता है।
4	m कई लाइनों से मेल खाता है, नई वर्णों को सामान्य पात्रों के रूप में पहचानता है।
5	u,e,s,n यूनीकोड ​​(UTF-8), EUC, SJIS या ASCII के रूप में regexp की व्याख्या करता है। यदि इनमें से कोई भी संशोधक निर्दिष्ट नहीं है, तो स्रोत एन्कोडिंग का उपयोग करने के लिए नियमित अभिव्यक्ति मान ली जाती है।

जैसे स्ट्रिंग शाब्दिकों को% Q के साथ सीमांकित किया गया है, रूबी आपको अपनी पसंद के परिसीमन के बाद% r के साथ अपने नियमित अभिव्यक्ति शुरू करने की अनुमति देता है। यह तब उपयोगी होता है जब आप जिस पैटर्न का वर्णन कर रहे होते हैं, उसमें बहुत सारे फ़ॉरवर्ड स्लैश अक्षर होते हैं, जिनसे आप बचना नहीं चाहते हैं -

# Following matches a single slash character, no escape required
%r|/|

# Flag characters are allowed with this syntax, too
%r[</(.*)>]i

नियमित अभिव्यक्ति पैटर्न

नियंत्रण वर्णों को छोड़कर, (+ ? . * ^ $ ( ) [ ] { } | \), सभी वर्ण खुद से मेल खाते हैं। आप एक बैकस्लैश के साथ पूर्ववर्ती द्वारा एक नियंत्रण चरित्र से बच सकते हैं।

निम्न तालिका रूबी में उपलब्ध नियमित अभिव्यक्ति सिंटैक्स को सूचीबद्ध करती है।

अनु क्रमांक।	पैटर्न और विवरण
1	^ लाइन की शुरुआत से मेल खाता है।
2	$ लाइन के अंत का मिलान।
3	. न्यूलाइन को छोड़कर किसी भी एकल वर्ण से मेल खाता है। M विकल्प का उपयोग करने से यह न्यूलाइन को भी मैच कर सकता है।
4	[...] कोष्ठक में किसी एक वर्ण से मेल खाता है।
5	[^...] किसी भी एकल वर्ण को कोष्ठक में नहीं मिलाता है
6	re* पूर्ववर्ती अभिव्यक्ति के 0 या अधिक घटनाओं से मेल खाता है।
7	re+ पूर्ववर्ती अभिव्यक्ति की 1 या अधिक घटना से मेल खाती है।
8	re? पूर्ववर्ती अभिव्यक्ति की 0 या 1 घटना से मेल खाता है।
9	re{ n} पूर्ववर्ती अभिव्यक्ति की घटनाओं की बिल्कुल n संख्या से मेल खाता है।
10	re{ n,} पूर्ववर्ती अभिव्यक्ति की n या अधिक घटनाओं से मेल खाता है।
1 1	re{ n, m} कम से कम n और पूर्ववर्ती अभिव्यक्ति के अधिकांश m घटनाओं पर मेल खाता है।
12	a| b माचिस या तो एक या बी।
13	(re) समूह नियमित अभिव्यक्ति और याद किए गए पाठ से मेल खाते हैं।
14	(?imx) एक नियमित अभिव्यक्ति के भीतर i, m या x विकल्पों पर अस्थायी रूप से टॉगल किया जाता है। यदि कोष्ठक में, केवल वह क्षेत्र प्रभावित होता है।
15	(?-imx) नियमित अभिव्यक्ति के भीतर मैं, मी, या x विकल्प बंद करता है। यदि कोष्ठक में, केवल वह क्षेत्र प्रभावित होता है।
16	(?: re) मिलान किए गए पाठ को याद किए बिना समूह नियमित अभिव्यक्ति।
17	(?imx: re) कोष्ठक के भीतर i, m या x विकल्पों पर अस्थायी रूप से टॉगल किया जाता है।
18	(?-imx: re) कोष्ठक के भीतर मैं, मी, या x विकल्प बंद करता है।
19	(?#...) टिप्पणी।
20	(?= re) एक पैटर्न का उपयोग करके स्थिति निर्दिष्ट करता है। एक सीमा नहीं है।
21	(?! re) पैटर्न नकार का उपयोग कर स्थिति निर्दिष्ट करता है। एक सीमा नहीं है।
22	(?> re) बैकट्रैकिंग के बिना स्वतंत्र पैटर्न से मेल खाता है।
23	\w शब्द वर्णों से मेल खाता है।
24	\W नॉनवर्ड कैरेक्टर से मेल खाता है।
25	\s व्हॉट्सएप से मेल खाता है। [\ T \ n \ r \ f] के बराबर।
26	\S नॉनवेजपेस से मेल खाता है।
27	\d अंकों का मिलान करता है। [0-9] के बराबर।
28	\D Nondigits से मेल खाता है।
29	\A स्ट्रिंग की शुरुआत से मेल खाता है।
30	\Z स्ट्रिंग का अंत मेल खाता है। यदि कोई नई रेखा मौजूद है, तो यह नई रेखा से ठीक पहले मेल खाती है।
31	\z स्ट्रिंग का अंत मेल खाता है।
32	\G मैच प्वाइंट जहां अंतिम मैच समाप्त हुआ।
33	\b शब्द सीमाएँ जब कोष्ठक के बाहर मिलती हैं। कोष्ठक के अंदर होने पर बैकस्पेस (0x08) से मेल खाता है।
34	\B गैर-शब्द सीमाओं से मेल खाता है।
35	\n, \t, etc. मेल खाती है नई गाड़ी, गाड़ी का रिटर्न, टैब आदि।
36	\1...\9 मेल nth समूहीकृत उपसक्रियता।
37	\10 यदि यह पहले से ही मेल खाता है तो nth समूहित उपसंचाई से मेल खाता है। अन्यथा एक चरित्र कोड के अष्टक प्रतिनिधित्व को संदर्भित करता है।

नियमित अभिव्यक्ति के उदाहरण

Literal Characters

अनु क्रमांक।	उदाहरण और विवरण
1	/ruby/ माणिक "माणिक"।
2	¥ येन चिन्ह से मेल खाता है। रूबी 1.9 और रूबी 1.8 में मल्टीबाइट पात्रों का समर्थन किया जाता है।

Character Classes

अनु क्रमांक।	उदाहरण और विवरण
1	/[Rr]uby/ "रूबी" या "रूबी" से मेल खाता है।
2	/rub[ye]/ "रूबी" या "रुब" से मेल खाता है।
3	/[aeiou]/ किसी एक लोअरकेस स्वर से मेल खाता है।
4	/[0-9]/ किसी भी अंक से मेल खाता है; के रूप में ही / [0123456789] /।
5	/[a-z]/ किसी भी लोअरकेस ASCII पत्र से मेल खाता है।
6	/[A-Z]/ किसी भी अपरकेस ASCII अक्षर से मेल खाता है।
7	/[a-zA-Z0-9]/ उपरोक्त में से कोई भी मेल खाता है।
8	/[^aeiou]/ एक लोअरकेस स्वर के अलावा कुछ भी मेल खाता है।
9	/[^0-9]/ एक अंक के अलावा कुछ भी मेल खाता है।

Special Character Classes

अनु क्रमांक।	उदाहरण और विवरण
1	/./ न्यूलाइन को छोड़कर किसी भी वर्ण से मेल खाता है।
2	/./m मल्टी-लाइन मोड में, नईलाइन से भी मेल खाता है।
3	/\d/ एक अंक से मेल खाता है: / [0-9] /।
4	/\D/ एक गैर-अंक से मेल खाता है: / [^ 0-9] /।
5	/\s/ एक व्हाट्सएप चरित्र से मेल खाता है: / [\ t \ r \ n \ f] /।
6	/\S/ गैर-व्हाट्सएप से मेल खाता है: / [^ \ t \ r \ n \ f] /।
7	/\w/ एकल शब्द वर्ण से मेल खाता है: / [A-Za-z0-9 _] /।
8	/\W/ एक गैर-शब्द वर्ण से मेल खाता है: / [^ A-Za-z0-9 _] /।

Repetition Cases

अनु क्रमांक।	उदाहरण और विवरण
1	/ruby?/ "रगड़" या "रूबी" से मेल खाता है: y वैकल्पिक है।
2	/ruby*/ "रगड़" प्लस 0 या अधिक वाईएस से मेल खाता है।
3	/ruby+/ "रगड़" प्लस 1 या अधिक वाईएस से मेल खाता है।
4	/\d{3}/ बिल्कुल 3 अंकों से मेल खाता है।
5	/\d{3,}/ 3 या अधिक अंकों से मेल खाता है।
6	/\d{3,5}/ 3, 4, या 5 अंक से मेल खाता है।

Non-greedy Repetition

यह पुनरावृत्ति की सबसे छोटी संख्या से मेल खाता है -

अनु क्रमांक।	उदाहरण और विवरण
1	/<.*>/ लालची दोहराव: "माणिक> पर्ल>" से मेल खाता है।
2	/<.*?>/ गैर-लालची: "<माणिक> पर्ल" में "<माणिक>" से मेल खाता है।

Grouping with Parentheses

अनु क्रमांक।	उदाहरण और विवरण
1	/\D\d+/ कोई समूह नहीं: + दोहराता है
2	/(\D\d)+/ समूहीकृत: + दोहराता \ D \ d जोड़ी
3	/([Rr]uby(, )?)+/ मैच "रूबी", "रूबी, रूबी, रूबी", आदि।

Back References

यह पहले से मिलान किए गए समूह से फिर से मेल खाता है -

अनु क्रमांक।	उदाहरण और विवरण
1	/([Rr])uby&\1ails/ माणिक और रेल या रूबी और रेल मेल।
2	/(['"])(?:(?!\1).)*\1/ सिंगल या डबल-उद्धृत स्ट्रिंग। 1 समूह से जो भी मेल खाता है, \ 1 मैच। \ 2 मैच 2 समूह से जो भी मेल खाता है, आदि।

Alternatives

अनु क्रमांक।	उदाहरण और विवरण
1	/ruby|rube/ "रूबी" या "रुब" से मेल खाता है।
2	/rub(y|le))/ "माणिक" या "रूबल" से मेल खाता है।
3	/ruby(!+|\?)/ "रूबी" एक या अधिक के बाद! या एक?

Anchors

इसे मैच की स्थिति निर्दिष्ट करने की आवश्यकता है।

अनु क्रमांक।	उदाहरण और विवरण
1	/^Ruby/ एक स्ट्रिंग या आंतरिक रेखा की शुरुआत में "रूबी" से मेल खाता है।
2	/Ruby$/ एक स्ट्रिंग या रेखा के अंत में "रूबी" से मेल खाता है।
3	/\ARuby/ एक स्ट्रिंग की शुरुआत में "रूबी" से मेल खाता है।
4	/Ruby\Z/ एक स्ट्रिंग के अंत में "रूबी" से मेल खाता है।
5	/\bRuby\b/ एक शब्द सीमा पर "रूबी" से मेल खाता है।
6	/\brub\B/ \ B गैर-शब्द सीमा है: "रब" और "रूबी" में "रगड़" से मेल खाता है, लेकिन अकेले नहीं।
7	/Ruby(?=!)/ "रूबी" से मेल खाता है, अगर विस्मयादिबोधक बिंदु के बाद।
8	/Ruby(?!!)/ "रूबी" से मेल खाता है, यदि विस्मयादिबोधक बिंदु द्वारा पीछा नहीं किया जाता है।

Special Syntax with Parentheses

अनु क्रमांक।	उदाहरण और विवरण
1	/R(?#comment)/ "आर" से मेल खाता है। बाकी सभी एक टिप्पणी है।
2	/R(?i)uby/ केस-असंवेदनशील "uby" से मेल खाते हुए।
3	/R(?i:uby)/ ऊपर की तरह।
4	/rub(?:y|le))/ केवल \ 1 backreference बनाए बिना समूह।

खोजें और बदलें

सबसे महत्वपूर्ण स्ट्रिंग विधियों में से कुछ नियमित अभिव्यक्ति का उपयोग करते हैं sub तथा gsub, और उनके इन-प्लेस वेरिएंट sub! तथा gsub!।

ये सभी तरीके Regexp पैटर्न का उपयोग करके एक खोज-और-जगह ऑपरेशन करते हैं। sub और sub! पैटर्न की पहली घटना की जगह लेता है और gsub और gsub! सभी घटनाओं को प्रतिस्थापित करता है।

sub तथा gsub एक नया स्ट्रिंग लौटाता है, जहां मूल असमान को छोड़ देता है sub! तथा gsub! उस स्ट्रिंग को संशोधित करें जिस पर उन्हें बुलाया जाता है।

निम्नलिखित उदाहरण है -

#!/usr/bin/ruby

phone = "2004-959-559 #This is Phone Number"

# Delete Ruby-style comments
phone = phone.sub!(/#.*$/, "")   
puts "Phone Num : #{phone}"

# Remove anything other than digits
phone = phone.gsub!(/\D/, "")    
puts "Phone Num : #{phone}"

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Phone Num : 2004-959-559
Phone Num : 2004959559

निम्नलिखित एक और उदाहरण है -

#!/usr/bin/ruby

text = "rails are rails, really good Ruby on Rails"

# Change "rails" to "Rails" throughout
text.gsub!("rails", "Rails")

# Capitalize the word "Rails" throughout
text.gsub!(/\brails\b/, "Rails")
puts "#{text}"

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Rails are Rails, really good Ruby on Rails

यह अध्याय आपको सिखाता है कि रूबी का उपयोग करके डेटाबेस तक कैसे पहुँचा जाए। रूबी DBI मॉड्यूल पर्ल DBI मॉड्यूल के समान रूबी स्क्रिप्ट के लिए एक डेटाबेस स्वतंत्र इंटरफेस प्रदान करता है।

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

डीबीआई निम्नलिखित के साथ इंटरफेस कर सकता है -

• ADO (ActiveX डेटा ऑब्जेक्ट)
• DB2
• Frontbase
• mSQL
• MySQL
• ODBC
• Oracle
• OCI8 (Oracle)
• PostgreSQL
• Proxy/Server
• SQLite
• SQLRelay

DBI एप्लिकेशन का आर्किटेक्चर

DBI बैकएंड में उपलब्ध किसी भी डेटाबेस से स्वतंत्र है। आप DBI का उपयोग कर सकते हैं चाहे आप Oracle, MySQL या Informix आदि के साथ काम कर रहे हों, यह निम्नलिखित आर्किटेक्चर आरेख से स्पष्ट है।

रूबी डीबीआई के लिए सामान्य वास्तुकला दो परतों का उपयोग करती है -

• डेटाबेस इंटरफ़ेस (DBI) परत। यह परत डेटाबेस स्वतंत्र है और सामान्य एक्सेस विधियों का एक सेट प्रदान करता है जो डेटाबेस सर्वर के प्रकार की परवाह किए बिना उसी तरह से उपयोग किए जाते हैं जिसके साथ आप संवाद कर रहे हैं।

• डेटाबेस ड्राइवर (DBD) परत। यह परत डेटाबेस पर निर्भर है; विभिन्न ड्राइवर विभिन्न डेटाबेस इंजनों तक पहुँच प्रदान करते हैं। MySQL के लिए एक ड्राइवर है, PostgreSQL के लिए एक और इंटरबेस के लिए एक और Oracle के लिए एक और इसके बाद का संस्करण है। प्रत्येक ड्राइवर DBI लेयर से अनुरोधों की व्याख्या करता है और उन्हें दिए गए डेटाबेस सर्वर के लिए उपयुक्त अनुरोधों पर मैप करता है।

आवश्यक शर्तें

यदि आप MySQL डेटाबेस तक पहुँचने के लिए रूबी स्क्रिप्ट लिखना चाहते हैं, तो आपको Ruby MySQL मॉड्यूल इंस्टॉल करना होगा।

यह मॉड्यूल ऊपर बताए अनुसार DBD के रूप में कार्य करता है और इससे डाउनलोड किया जा सकता है https://www.tmtm.org/en/mysql/ruby/

रूबी / डीबीआई को प्राप्त करना और स्थापित करना

आप निम्न स्थान से रूबी डीबीआई मॉड्यूल डाउनलोड और स्थापित कर सकते हैं -

https://imgur.com/NFEuWe4/embed

इस स्थापना को शुरू करने से पहले सुनिश्चित करें कि आपके पास रूट विशेषाधिकार है। अब, नीचे दिए गए चरणों का पालन करें -

चरण 1

$ tar zxf dbi-0.2.0.tar.gz

चरण 2

वितरण निर्देशिका में जाएं dbi-0.2.0 nd इसे उस निर्देशिका में setup.rb स्क्रिप्ट का उपयोग करके कॉन्फ़िगर करें । सबसे सामान्य कॉन्फ़िगरेशन कमांड इस तरह दिखता है, जिसमें कॉन्फ़िगरेशन तर्क के बाद कोई तर्क नहीं है। यह आदेश डिफ़ॉल्ट रूप से सभी ड्राइवरों को स्थापित करने के लिए वितरण को कॉन्फ़िगर करता है।

$ ruby setup.rb config

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

$ ruby setup.rb config --with = dbi,dbd_mysql

चरण 3

अंतिम चरण ड्राइवर का निर्माण करना है और इसे निम्नलिखित कमांड का उपयोग करके स्थापित करना है -

$ ruby setup.rb setup $ ruby setup.rb install

डेटाबेस कनेक्शन

यह मानते हुए कि हम MySQL डेटाबेस के साथ काम करने जा रहे हैं, डेटाबेस से कनेक्ट करने से पहले निम्नलिखित सुनिश्चित करें -

• आपने एक डेटाबेस बनाया है TESTDB।

• आपने TESTDB में EMPLOYEE बनाया है।

• इस तालिका में FIRST_NAME, LAST_NAME, AGE, SEX और INCOME फ़ील्ड हैं।

• उपयोगकर्ता ID "testuser" और पासवर्ड "test123" TESTDB तक पहुँचने के लिए निर्धारित हैं।

• रूबी मॉड्यूल डीबीआई आपकी मशीन पर ठीक से स्थापित है।

• आप MySQL बेसिक्स को समझने के लिए MySQL ट्यूटोरियल से गुजरे हैं।

निम्नलिखित MySQL डेटाबेस "TESTDB" से जुड़ने का उदाहरण है

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   # get server version string and display it
   row = dbh.select_one("SELECT VERSION()")
   puts "Server version: " + row[0]
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

इस स्क्रिप्ट को चलाते समय, यह हमारे लिनक्स मशीन पर निम्न परिणाम तैयार करता है।

Server version: 5.0.45

यदि डेटा स्रोत के साथ एक कनेक्शन स्थापित किया गया है, तो एक डेटाबेस हैंडल को वापस लौटाया जाता है और इसमें सहेजा जाता है dbh आगे उपयोग के लिए अन्यथा dbhशून्य मान और e.err पर सेट है और e :: क्रमशः त्रुटि त्रुटि कोड और एक त्रुटि स्ट्रिंग।

अंत में, इसे बाहर आने से पहले, सुनिश्चित करें कि डेटाबेस कनेक्शन बंद है और संसाधन जारी किए गए हैं।

INSERT ऑपरेशन

जब आप अपने रिकॉर्ड डेटाबेस तालिका में बनाना चाहते हैं, तो INSERT ऑपरेशन आवश्यक है।

डेटाबेस कनेक्शन स्थापित होने के बाद, हम डेटाबेस तालिकाओं में तालिकाओं या रिकॉर्ड बनाने के लिए तैयार हैं do विधि या prepare तथा execute तरीका।

कथन का उपयोग करना

वे कथन जो पंक्तियों को वापस नहीं लाते हैं उन्हें जारी करके जारी किया जा सकता है doडेटाबेस संभाल विधि। यह विधि एक स्टेटमेंट स्ट्रिंग तर्क लेती है और स्टेटमेंट से प्रभावित पंक्तियों की संख्या की एक गिनती लौटाती है।

dbh.do("DROP TABLE IF EXISTS EMPLOYEE")
dbh.do("CREATE TABLE EMPLOYEE (
   FIRST_NAME  CHAR(20) NOT NULL,
   LAST_NAME  CHAR(20),
   AGE INT,  
   SEX CHAR(1),
   INCOME FLOAT )" );

इसी तरह, आप EMPLOYEE तालिका में रिकॉर्ड बनाने के लिए SQL INSERT विवरण निष्पादित कर सकते हैं ।

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   dbh.do( "INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
      VALUES ('Mac', 'Mohan', 20, 'M', 2000)" )
   puts "Record has been created"
   dbh.commit
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

तैयारी का उपयोग करें और निष्पादित करें

आप रूबी कोड के माध्यम से एसक्यूएल स्टेटमेंट को निष्पादित करने के लिए डीबीआई क्लास के तरीकों को तैयार और निष्पादित कर सकते हैं ।

रिकॉर्ड निर्माण में निम्नलिखित कदम हैं -

• INSERT स्टेटमेंट के साथ SQL स्टेटमेंट तैयार करना। यह का उपयोग करके किया जाएगाprepare तरीका।

• डेटाबेस से सभी परिणामों का चयन करने के लिए SQL क्वेरी निष्पादित करना। यह का उपयोग करके किया जाएगाexecute तरीका।

• स्टेटमेंट हैंडल जारी करना। यह प्रयोग करके किया जाएगाfinish एपीआई

• अगर सबकुछ ठीक हो जाता है, तो commit यह ऑपरेशन अन्यथा आप कर सकते हैं rollback पूरा लेन-देन।

इन दो विधियों का उपयोग करने के लिए सिंटैक्स निम्नलिखित है -

sth = dbh.prepare(statement)
sth.execute
   ... zero or more SQL operations ...
sth.finish

इन दो तरीकों को पारित करने के लिए इस्तेमाल किया जा सकता है bindSQL कथन के लिए मान। ऐसा कोई मामला हो सकता है जब दर्ज किए जाने वाले मान अग्रिम में नहीं दिए गए हों। ऐसे मामले में, बाध्यकारी मूल्यों का उपयोग किया जाता है। एक प्रश्न चिह्न (?) का उपयोग वास्तविक मूल्यों के स्थान पर किया जाता है और फिर वास्तविक मूल्यों को निष्पादन () एपीआई के माध्यम से पारित किया जाता है।

EMPLOYEE तालिका में दो रिकॉर्ड बनाने के लिए निम्नलिखित उदाहरण है -

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   sth = dbh.prepare( "INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
      VALUES (?, ?, ?, ?, ?)" )
   sth.execute('John', 'Poul', 25, 'M', 2300)
   sth.execute('Zara', 'Ali', 17, 'F', 1000)
   sth.finish
   dbh.commit
   puts "Record has been created"
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

यदि एक समय में कई INSERT हैं, तो पहले एक स्टेटमेंट तैयार करना और फिर इसे लूप के भीतर हर बार निष्पादित करने की तुलना में कई बार निष्पादित करना लूप के माध्यम से हर बार लागू करने से अधिक कुशल है।

पढ़ें ऑपरेशन

किसी भी डेटाबेस पर पढ़ें ऑपरेशन का मतलब डेटाबेस से कुछ उपयोगी जानकारी प्राप्त करना है।

एक बार हमारा डेटाबेस कनेक्शन स्थापित हो जाने के बाद, हम इस डेटाबेस में एक प्रश्न बनाने के लिए तैयार हैं। हम या तो उपयोग कर सकते हैंdo विधि या prepare तथा execute एक डेटाबेस टेबल से मूल्यों को लाने के तरीके।

रिकॉर्ड लाने के लिए निम्नलिखित कदम उठाए गए हैं

• आवश्यक शर्तों के आधार पर SQL क्वेरी तैयार करना। यह का उपयोग करके किया जाएगाprepare तरीका।

• डेटाबेस से सभी परिणामों का चयन करने के लिए SQL क्वेरी निष्पादित करना। यह का उपयोग करके किया जाएगाexecute तरीका।

• सभी परिणामों को एक-एक करके प्राप्त करना और उन परिणामों को प्रिंट करना। यह का उपयोग करके किया जाएगाfetch तरीका।

• स्टेटमेंट हैंडल जारी करना। यह का उपयोग करके किया जाएगाfinish तरीका।

निम्नलिखित 1000 से अधिक वेतन वाले EMPLOYEE तालिका से सभी रिकॉर्ड को क्वेरी करने की प्रक्रिया है।

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   sth = dbh.prepare("SELECT * FROM EMPLOYEE WHERE INCOME > ?")
   sth.execute(1000)

   sth.fetch do |row|
   printf "First Name: %s, Last Name : %s\n", row[0], row[1]
   printf "Age: %d, Sex : %s\n", row[2], row[3]
   printf "Salary :%d \n\n", row[4]
end
   sth.finish
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

यह निम्नलिखित परिणाम का उत्पादन करेगा -

First Name: Mac, Last Name : Mohan
Age: 20, Sex : M
Salary :2000

First Name: John, Last Name : Poul
Age: 25, Sex : M
Salary :2300

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

अद्यतन अद्यतन

किसी भी डेटाबेस पर अद्यतन ऑपरेशन का मतलब एक या एक से अधिक रिकॉर्ड को अद्यतन करना है, जो पहले से ही डेटाबेस में उपलब्ध हैं। निम्नलिखित सभी अभिलेखों को 'एम' के रूप में अद्यतन करने की प्रक्रिया है। यहां, हम सभी पुरुषों के एजीई को एक वर्ष तक बढ़ाएंगे। इसके लिए तीन कदम उठाए जाएंगे -

• आवश्यक शर्तों के आधार पर SQL क्वेरी तैयार करना। यह का उपयोग करके किया जाएगाprepare तरीका।

• डेटाबेस से सभी परिणामों का चयन करने के लिए SQL क्वेरी निष्पादित करना। यह का उपयोग करके किया जाएगाexecute तरीका।

• स्टेटमेंट हैंडल जारी करना। यह का उपयोग करके किया जाएगाfinish तरीका।

• अगर सब कुछ ठीक रहा तो commit यह ऑपरेशन अन्यथा आप कर सकते हैं rollback पूरा लेन-देन।

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   sth = dbh.prepare("UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = ?")
   sth.execute('M')
   sth.finish
   dbh.commit
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

DELETE ऑपरेशन

DELETE ऑपरेशन की आवश्यकता तब होती है जब आप अपने डेटाबेस से कुछ रिकॉर्ड हटाना चाहते हैं। निम्नलिखित EMPLOYEE से सभी रिकॉर्ड को हटाने की प्रक्रिया है, जहां AGE 20 से अधिक है। यह ऑपरेशन निम्न चरणों का पालन करेगा।

• आवश्यक शर्तों के आधार पर SQL क्वेरी तैयार करना। यह का उपयोग करके किया जाएगाprepare तरीका।

• डेटाबेस से आवश्यक रिकॉर्ड को हटाने के लिए SQL क्वेरी निष्पादित करना। यह का उपयोग करके किया जाएगाexecute तरीका।

• स्टेटमेंट हैंडल जारी करना। यह का उपयोग करके किया जाएगाfinish तरीका।

• अगर सब कुछ ठीक रहा तो commit यह ऑपरेशन अन्यथा आप कर सकते हैं rollback पूरा लेन-देन।

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   sth = dbh.prepare("DELETE FROM EMPLOYEE WHERE AGE > ?")
   sth.execute(20)
   sth.finish
   dbh.commit
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

लेन-देन करना

लेन-देन एक तंत्र है जो डेटा स्थिरता सुनिश्चित करता है। लेनदेन में निम्नलिखित चार गुण होने चाहिए -

• Atomicity - या तो लेनदेन पूरा हो जाता है या कुछ भी नहीं होता है।

• Consistency - एक लेन-देन एक सुसंगत स्थिति में शुरू होना चाहिए और सिस्टम को छोड़ना एक सुसंगत स्थिति है।

• Isolation - लेन-देन के मध्यवर्ती परिणाम वर्तमान लेनदेन के बाहर दिखाई नहीं देते हैं।

• Durability - एक बार लेनदेन किए जाने के बाद, सिस्टम की विफलता के बाद भी प्रभाव लगातार बना रहता है।

DBI दो तरीकों या तो करने के लिए प्रदान करता है प्रतिबद्ध या रोलबैक एक सौदे। लेनदेन नामक एक और विधि है जिसका उपयोग लेनदेन को लागू करने के लिए किया जा सकता है। लेनदेन को लागू करने के लिए दो सरल तरीके हैं -

दृष्टिकोण मैं

पहला दृष्टिकोण डीबीआई की प्रतिबद्ध और रोलबैक विधियों का उपयोग लेनदेन को स्पष्ट रूप से करने या रद्द करने के लिए करता है -

dbh['AutoCommit'] = false # Set auto commit to false.
begin
   dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 WHERE FIRST_NAME = 'John'")
   dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 WHERE FIRST_NAME = 'Zara'")
   dbh.commit
rescue
   puts "transaction failed"
   dbh.rollback
end
dbh['AutoCommit'] = true

दृष्टिकोण II

दूसरा दृष्टिकोण लेनदेन पद्धति का उपयोग करता है । यह सरल है, क्योंकि यह एक कोड ब्लॉक करता है जिसमें स्टेटमेंट होते हैं जो लेनदेन करते हैं। लेन-देन विधि ब्लॉक निष्पादित करता है, तो आह्वान प्रतिबद्ध या रोलबैक स्वचालित रूप से, पर ब्लॉक सफल होता है या विफल रहता है कि क्या निर्भर करता है -

dbh['AutoCommit'] = false # Set auto commit to false.
dbh.transaction do |dbh|
   dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 WHERE FIRST_NAME = 'John'")
   dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 WHERE FIRST_NAME = 'Zara'")
end
dbh['AutoCommit'] = true

COMMIT ऑपरेशन

कमिट वह ऑपरेशन है, जो बदलावों को अंतिम रूप देने के लिए डेटाबेस को हरी झंडी देता है और इस ऑपरेशन के बाद कोई भी बदलाव वापस नहीं किया जा सकता है।

यहां कॉल करने के लिए एक सरल उदाहरण है commit तरीका।

dbh.commit

रोलबैक ऑपरेशन

यदि आप एक या अधिक परिवर्तनों से संतुष्ट नहीं हैं और आप उन परिवर्तनों को पूरी तरह से वापस लेना चाहते हैं, तो उपयोग करें rollback तरीका।

यहां कॉल करने के लिए एक सरल उदाहरण है rollback तरीका।

dbh.rollback

डेटाबेस को डिस्कनेक्ट कर रहा है

डेटाबेस कनेक्शन को डिस्कनेक्ट करने के लिए, डिस्कनेक्ट एपीआई का उपयोग करें।

dbh.disconnect

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

त्रुटियों को संभालना

त्रुटियों के कई स्रोत हैं। कुछ उदाहरण एक निष्पादित SQL स्टेटमेंट, एक कनेक्शन विफलता, या पहले से रद्द किए गए स्टेटमेंट हैंडल के लिए भ्रूण विधि को कॉल करने में एक सिंटैक्स त्रुटि है।

यदि कोई DBI विधि विफल हो जाती है, तो DBI एक अपवाद उठाता है। DBI विधियाँ किसी भी प्रकार के अपवाद को बढ़ा सकती हैं लेकिन दो सबसे महत्वपूर्ण अपवाद वर्ग DBI :: InterfaceError और DBI :: DatabaseError हैं ।

इन कक्षाओं के अपवाद वस्तुओं नामित तीन गुण अं , errstr , और राज्य है, जो त्रुटि संख्या, एक वर्णनात्मक त्रुटि स्ट्रिंग, और एक मानक त्रुटि कोड का प्रतिनिधित्व करते हैं। विशेषताओं को नीचे समझाया गया है -

• err- यदि यह DBD द्वारा समर्थित नहीं है, तो हुई त्रुटि या शून्य का पूर्णांक निरूपण देता है। उदाहरण के लिए Oracle DBD एक ORA-XXXX त्रुटि संदेश का संख्यात्मक भाग लौटाता है ।

• errstr - हुई त्रुटि का एक स्ट्रिंग प्रतिनिधित्व लौटाता है।

• state- हुई त्रुटि का SQLSTATE कोड लौटाता है। SQLSTATE पांच वर्णों वाली लंबी स्ट्रिंग है। अधिकांश डीबीडी इसका समर्थन नहीं करते हैं और इसके बजाय शून्य लौटाते हैं।

आपने ज्यादातर उदाहरणों में निम्नलिखित कोड देखे हैं -

rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

डिबगिंग जानकारी प्राप्त करने के लिए कि आपकी स्क्रिप्ट क्या निष्पादित कर रही है, आप ट्रेसिंग को सक्षम कर सकते हैं। ऐसा करने के लिए, आपको पहले dbi / ट्रेस मॉड्यूल लोड करना होगा और फिर ट्रेस विधि को कॉल करना चाहिए जो ट्रेस मोड और आउटपुट डेस्टिनेशन को नियंत्रित करता है -

require "dbi/trace"
..............

trace(mode, destination)

मोड मान 0 (ऑफ), 1, 2 या 3 हो सकता है, और गंतव्य एक IO ऑब्जेक्ट होना चाहिए। डिफ़ॉल्ट मान क्रमशः 2 और STDERR हैं।

विधियों के साथ कोड ब्लॉक

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

• DBI.connect- यह विधि एक डेटाबेस हैंडल उत्पन्न करती है और डेटाबेस को डिस्कनेक्ट करने के लिए ब्लॉक के अंत में डिस्कनेक्ट को कॉल करने की सिफारिश की जाती है ।

• dbh.prepare- यह विधि एक स्टेटमेंट हैंडल बनाती है और इसे ब्लॉक के अंत में समाप्त करने की सिफारिश की जाती है । ब्लॉक के भीतर, आपको स्टेटमेंट निष्पादित करने के लिए एग्जीक्यूट विधि को लागू करना होगा ।

• dbh.execute- यह विधि समान है सिवाय इसके कि हमें ब्लॉक के भीतर निष्पादित करने की आवश्यकता नहीं है। स्टेटमेंट हैंडल को स्वचालित रूप से निष्पादित किया जाता है।

उदाहरण 1

DBI.connect एक कोड ब्लॉक ले सकता है, डेटाबेस हैंडल को पास करता है, और ब्लॉक के अंत में स्वचालित रूप से हैंडल को डिस्कनेक्ट करता है।

dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123") do |dbh|

उदाहरण 2

dbh.prepare एक कोड ब्लॉक ले सकता है, स्टेटमेंट हैंडल को पास करता है, और ब्लॉक के अंत में स्वचालित रूप से कॉल को निम्न प्रकार से कॉल करता है।

dbh.prepare("SHOW DATABASES") do |sth|
   sth.execute
   puts "Databases: " + sth.fetch_all.join(", ")
end

उदाहरण 3

dbh.execute एक कोड ब्लॉक ले सकता है, स्टेटमेंट हैंडल को पास करता है, और ब्लॉक के अंत में स्वचालित रूप से कॉल को निम्नानुसार पूरा करता है -

dbh.execute("SHOW DATABASES") do |sth|
   puts "Databases: " + sth.fetch_all.join(", ")
end

डीबीआई लेनदेन विधि एक कोड ब्लॉक भी लेती है जिसे ऊपर वर्णित किया गया है।

ड्राइवर-विशिष्ट कार्य और गुण

DBI डेटाबेस ड्राइवरों को अतिरिक्त डेटाबेस-विशिष्ट फ़ंक्शन प्रदान करने देता है, जिसे उपयोगकर्ता द्वारा किसी भी हैंडल ऑब्जेक्ट की फ़ंक विधि के माध्यम से कॉल किया जा सकता है ।

ड्राइवर-विशिष्ट विशेषताओं का समर्थन किया जाता है और इसका उपयोग करके सेट या प्राप्त किया जा सकता है []= या [] तरीकों।

DBD :: Mysql निम्नलिखित ड्राइवर-विशिष्ट कार्यों को लागू करता है -

अनु क्रमांक।	कार्य और विवरण
1	dbh.func(:createdb, db_name) एक नया डेटाबेस बनाता है।
2	dbh.func(:dropdb, db_name) एक डेटाबेस को गिराता है।
3	dbh.func(:reload) पुनः लोड ऑपरेशन करता है।
4	dbh.func(:shutdown) सर्वर को बंद कर देता है।
5	dbh.func(:insert_id) => Fixnum किसी कनेक्शन के लिए सबसे हाल का AUTO_INCREMENT मान लौटाता है।
6	dbh.func(:client_info) => String संस्करण के संदर्भ में MySQL क्लाइंट जानकारी लौटाता है।
7	dbh.func(:client_version) => Fixnum संस्करण के संदर्भ में क्लाइंट की जानकारी देता है। यह इसके जैसा है: client_info लेकिन यह स्टिंग के बजाय एक फ़िक्नम लौटाता है।
8	dbh.func(:host_info) => String मेजबान जानकारी देता है।
9	dbh.func(:proto_info) => Fixnum संचार के लिए इस्तेमाल किया जा रहा प्रोटोकॉल लौटाता है।
10	dbh.func(:server_info) => String संस्करण के संदर्भ में MySQL सर्वर जानकारी देता है।
1 1	dbh.func(:stat) => String डेटाबेस की वर्तमान स्थिति देता है।
12	dbh.func(:thread_id) => Fixnum वर्तमान थ्रेड आईडी लौटाता है।

उदाहरण

#!/usr/bin/ruby

require "dbi"
begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123") 
   puts dbh.func(:client_info)
   puts dbh.func(:client_version)
   puts dbh.func(:host_info)
   puts dbh.func(:proto_info)
   puts dbh.func(:server_info)
   puts dbh.func(:thread_id)
   puts dbh.func(:stat)
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
ensure
   dbh.disconnect if dbh
end

यह निम्नलिखित परिणाम का उत्पादन करेगा -

5.0.45
50045
Localhost via UNIX socket
10
5.0.45
150621
Uptime: 384981  Threads: 1  Questions: 1101078  Slow queries: 4 \
Opens: 324  Flush tables: 1  Open tables: 64  \
Queries per second avg: 2.860

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

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

कृपया CGI प्रोग्रामिंग पर अधिक विस्तार के लिए CGI प्रोग्रामिंग ट्यूटोरियल के साथ कुछ मिनट बिताएं ।

लेखन CGI लिपियों

सबसे बुनियादी रूबी CGI स्क्रिप्ट इस प्रकार है -

#!/usr/bin/ruby

puts "HTTP/1.0 200 OK"
puts "Content-type: text/html\n\n"
puts "<html><body>This is a test</body></html>"

यदि आप इस स्क्रिप्ट को test.cgi कहते हैं और इसे यूनिक्स-आधारित वेब होस्टिंग प्रदाता के पास सही अनुमतियों के साथ अपलोड किया है, तो आप इसे CGI स्क्रिप्ट के रूप में उपयोग कर सकते हैं।

उदाहरण के लिए, यदि आपके पास वेब साइट है https://www.example.com/लिनक्स वेब होस्टिंग प्रदाता के साथ होस्ट किया गया है और आप test.cgi को मुख्य निर्देशिका में अपलोड करते हैं और इसे अनुमति देते हैं, फिर जाकरhttps://www.example.com/test.cgi एक HTML पृष्ठ यह कहते हुए वापस करना चाहिए This is a test।

जब वेब ब्राउज़र से test.cgi का अनुरोध किया जाता है, तो वेब सर्वर वेब साइट पर test.cgi की तलाश करता है, और फिर रूबी दुभाषिया का उपयोग करके इसे निष्पादित करता है। रूबी स्क्रिप्ट एक मूल HTTP शीर्ष लेख देता है और फिर एक मूल HTML दस्तावेज़ देता है।

Cgi.rb का उपयोग करना

रूबी नामक एक विशेष पुस्तकालय के साथ आता है cgi पूर्ववर्ती CGI स्क्रिप्ट के साथ उन लोगों की तुलना में अधिक परिष्कृत इंटरैक्शन सक्षम करता है।

आइए एक मूल CGI स्क्रिप्ट बनाएं जो cgi का उपयोग करता है -

#!/usr/bin/ruby

require 'cgi'
cgi = CGI.new

puts cgi.header
puts "<html><body>This is a test</body></html>"

यहां, आपने एक CGI ऑब्जेक्ट बनाया और इसका उपयोग हेडर लाइन को आपके लिए प्रिंट करने के लिए किया।

फार्म प्रसंस्करण

वर्ग सीजीआई का उपयोग करना आपको दो तरीकों से HTML क्वेरी मापदंडों तक पहुंच प्रदान करता है। मान लीजिए कि हमें /cgi-bin/test.cgi?FirstName = ज़ारा और लास्टनाम = अली का URL दिया गया है।

आप पैरामीटर का उपयोग कर सकते हैं FirstName और LastName का उपयोग कर CGI # [] सीधे इस प्रकार है -

#!/usr/bin/ruby

require 'cgi'
cgi = CGI.new
cgi['FirstName'] # =>  ["Zara"]
cgi['LastName']  # =>  ["Ali"]

इन फ़ॉर्म चर तक पहुंचने का एक और तरीका है। यह कोड आपको सभी कुंजी और मूल्यों का हैश देगा -

#!/usr/bin/ruby

require 'cgi'
cgi = CGI.new
h = cgi.params  # =>  {"FirstName"=>["Zara"],"LastName"=>["Ali"]}
h['FirstName']  # =>  ["Zara"]
h['LastName']   # =>  ["Ali"]

निम्नलिखित सभी कुंजियों को पुनः प्राप्त करने के लिए कोड है -

#!/usr/bin/ruby

require 'cgi'
cgi = CGI.new
cgi.keys         # =>  ["FirstName", "LastName"]

यदि किसी प्रपत्र में एक ही नाम के साथ कई फ़ील्ड होते हैं, तो संबंधित मान एक सरणी के रूप में स्क्रिप्ट पर वापस आ जाएंगे। [] एक्‍सर इनमे से पहला रिटर्न देता है। इन सबको पाने के लिए परमेस विधि का परिणाम है।

इस उदाहरण में, मान लें कि प्रपत्र में "नाम" नामक तीन फ़ील्ड हैं और हमने तीन नाम "ज़ारा", "हुमा" और "न्यूडा" में दर्ज किए -

#!/usr/bin/ruby

require 'cgi'
cgi = CGI.new
cgi['name']        # => "Zara"
cgi.params['name'] # => ["Zara", "Huma", "Nuha"]
cgi.keys           # => ["name"]
cgi.params         # => {"name"=>["Zara", "Huma", "Nuha"]}

Note- रूबी स्वचालित रूप से GET और POST विधियों का ध्यान रखेगी। इन दो अलग-अलग तरीकों के लिए कोई अलग उपचार नहीं है।

एक संबद्ध, लेकिन मूल, फॉर्म जो सही डेटा भेज सकता है, उसमें HTML कोड होगा जैसे -

<html>
   <body>
      <form method = "POST" action = "http://www.example.com/test.cgi">
         First Name :<input type = "text" name = "FirstName" value = "" />
         <br />
         Last Name :<input type = "text" name = "LastName" value = "" /> 
         <input type = "submit" value = "Submit Data" />
      </form>
   </body>
</html>

प्रपत्र और HTML बनाना

सीजीआई में HTML बनाने के लिए उपयोग की जाने वाली विधियों की एक बड़ी संख्या है। आपको प्रति टैग एक विधि मिलेगी। इन विधियों को सक्षम करने के लिए, आपको CGI.new पर कॉल करके एक CGI ऑब्जेक्ट बनाना होगा।

टैग नेस्टिंग को आसान बनाने के लिए, ये विधियाँ अपनी सामग्री को कोड ब्लॉक के रूप में लेती हैं। कोड ब्लॉक को एक स्ट्रिंग लौटना चाहिए , जिसका उपयोग टैग के लिए सामग्री के रूप में किया जाएगा। उदाहरण के लिए -

#!/usr/bin/ruby

require "cgi"
cgi = CGI.new("html4")
cgi.out {
   cgi.html {
      cgi.head { "\n"+cgi.title{"This Is a Test"} } +
      cgi.body { "\n"+
         cgi.form {"\n"+
            cgi.hr +
            cgi.h1 { "A Form: " } + "\n"+
            cgi.textarea("get_text") +"\n"+
            cgi.br +
            cgi.submit
         }
      }
   }
}

NOTE- CGI क्लास का फॉर्म मेथड एक मेथड पैरामीटर स्वीकार कर सकता है, जो फॉर्म सबमिटल पर इस्तेमाल करने के लिए HTTP मेथड (GET, POST, और इसी तरह ...) सेट करेगा। इस उदाहरण में प्रयुक्त डिफ़ॉल्ट, POST है।

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Content-Type: text/html
Content-Length: 302

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Final//EN">

<HTML>
   <HEAD>
      <TITLE>This Is a Test</TITLE>
   </HEAD>
   <BODY>
      <FORM METHOD = "post" ENCTYPE = "application/x-www-form-urlencoded">
         <HR>
         <H1>A Form: </H1>
         <TEXTAREA COLS = "70" NAME = "get_text" ROWS = "10"></TEXTAREA>
         <BR>
         <INPUT TYPE = "submit">
      </FORM>
   </BODY>
</HTML>

स्ट्रिंग का हवाला देते हुए

URL और HTML कोड के साथ काम करते समय, आपको कुछ वर्णों को उद्धृत करने के लिए सावधान रहना चाहिए। उदाहरण के लिए, एक स्लैश चरित्र (/) का URL में विशेष अर्थ है, इसलिए यह होना चाहिएescaped अगर यह pathname का हिस्सा नहीं है।

उदाहरण के लिए, URL के क्वेरी भाग में से किसी भी / को स्ट्रिंग% 2F में अनुवादित किया जाएगा और इसका उपयोग करने के लिए आपको वापस / इसके लिए अनुवाद करना होगा। अंतरिक्ष और एम्परसेंड भी विशेष पात्र हैं। इसे संभालने के लिए, CGI दिनचर्या प्रदान करता हैCGI.escape तथा CGI.unescape।

#!/usr/bin/ruby

require 'cgi'
puts CGI.escape(Zara Ali/A Sweet & Sour Girl")

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Zara+Ali%2FA Sweet+%26+Sour+Girl")

#!/usr/bin/ruby

require 'cgi'
puts CGI.escapeHTML('<h1>Zara Ali/A Sweet & Sour Girl</h1>')

यह निम्नलिखित परिणाम का उत्पादन करेगा -

<h1>Zara Ali/A Sweet & Sour Girl</h1>'

सीजीआई कक्षा में उपयोगी तरीके

यहां सीजीआई वर्ग से संबंधित विधियों की सूची दी गई है -

• रूबी सीजीआई - विधियों स्टैंडर्ड सीजीआई पुस्तकालय से संबंधित।

कुकीज़ और सत्र

हमने इन दो अवधारणाओं को विभिन्न वर्गों में समझाया है। कृपया वर्गों का अनुसरण करें -

• रूबी सीजीआई कुकीज़ - कैसे सीजीआई कुकीज़ को संभालने के लिए।

• रूबी सीजीआई सत्र - कैसे सीजीआई सत्र प्रबंधित करने।

वेब होस्टिंग सर्वर

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

• यूनिक्स-आधारित वेब होस्टिंग

सिंपल मेल ट्रांसफर प्रोटोकॉल (SMTP) एक प्रोटोकॉल है, जो मेल सर्वर के बीच ई-मेल और राउटिंग ई-मेल भेजने का काम करता है।

रूबी सरल मेल ट्रांसफर प्रोटोकॉल (SMTP) क्लाइंट-साइड कनेक्शन के लिए नेट :: SMTP वर्ग प्रदान करता है और दो वर्ग विधियों को नया और प्रारंभ प्रदान करता है ।

• new दो पैरामीटर लेता है -

  • सर्वर नाम स्थानीय होस्ट करने के लिए दोषी।

  • पोर्ट संख्या अच्छी तरह से ज्ञात पोर्ट 25 को दोषी।

• start विधि इन मापदंडों लेता है -

  • सर्वर - एसएमटीपी सर्वर का आईपी नाम, स्थानीय होस्ट करने के लिए दोषी।

  • पोर्ट - पोर्ट संख्या, 25 को दोषी।

  • डोमेन - मेल भेजने वाले का डोमेन, ENV [ "HOSTNAME"] के लिए दोषी।

  • खाता - प्रयोक्ता नाम, डिफ़ॉल्ट के बराबर है।

  • पासवर्ड - उपयोगकर्ता पासवर्ड, नहीं के बराबर करने के लिए दोषी।

  • AuthType - प्राधिकरण प्रकार, के लिए दोषी cram_md5 ।

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

• स्रोत - स्ट्रिंग या सरणी या एक के साथ कुछ भी प्रत्येक इटरेटर एक समय में एक स्ट्रिंग लौटने।

• इस - स्ट्रिंग में दिखाई देंगे से ईमेल के क्षेत्र।

• प्राप्तकर्ताओं - स्ट्रिंग या प्राप्तकर्ताओं के पत्र पानेवाला (रों) का प्रतिनिधित्व तार की एक सरणी।

उदाहरण

यहां रूबी स्क्रिप्ट का उपयोग करके एक ईमेल भेजने का एक सरल तरीका है। एक बार आजमा कर देखें -

require 'net/smtp'

message = <<MESSAGE_END
From: Private Person <[email protected]>
To: A Test User <[email protected]>
Subject: SMTP e-mail test

This is a test e-mail message.
MESSAGE_END

Net::SMTP.start('localhost') do |smtp|
  smtp.send_message message, '[email protected]', '[email protected]'
end

यहां, आपने एक डॉक्यूमेंट का उपयोग करके, हेडर को सही ढंग से प्रारूपित करने के लिए देखभाल करते हुए संदेश में एक बुनियादी ई-मेल रखा है। ई-मेल की आवश्यकता हैFrom, To, तथा Subject हेडर, एक खाली लाइन के साथ ई-मेल के शरीर से अलग हो गया।

मेल भेजने के लिए आप स्थानीय मशीन पर SMTP सर्वर से कनेक्ट करने के लिए Net :: SMTP का उपयोग करते हैं और फिर संदेश, पते से और गंतव्य पते के साथ send_message पद्धति का उपयोग मापदंडों के रूप में करते हैं (भले ही वह और पते से हो ई-मेल के भीतर ही, ये हमेशा मेल रूट करने के लिए उपयोग नहीं किए जाते हैं)।

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

Net::SMTP.start('mail.your-domain.com')

कोड की यह पंक्ति किसी भी उपयोगकर्ता नाम या पासवर्ड का उपयोग किए बिना mail.your-domain.com के पोर्ट 25 पर SMTP सर्वर से कनेक्ट होती है। यदि आपको जरूरत है, तो आप पोर्ट नंबर और अन्य विवरण निर्दिष्ट कर सकते हैं। उदाहरण के लिए -

Net::SMTP.start('mail.your-domain.com', 
                25, 
                'localhost', 
                'username', 'password' :plain)

यह उदाहरण SMTP सर्वर से mail.your-domain.com पर सादा पाठ प्रारूप में उपयोगकर्ता नाम और पासवर्ड का उपयोग करता है। यह क्लाइंट के होस्टनाम को लोकलहोस्ट के रूप में पहचानता है।

रूबी का उपयोग करके HTML ई-मेल भेजना

जब आप रूबी का उपयोग करके एक पाठ संदेश भेजते हैं तो सभी सामग्री को सरल पाठ माना जाएगा। यहां तक ​​कि अगर आप एक टेक्स्ट संदेश में HTML टैग शामिल करेंगे, तो इसे सरल पाठ के रूप में प्रदर्शित किया जाएगा और HTML टैग्स को HTML सिंटैक्स के अनुसार स्वरूपित नहीं किया जाएगा। लेकिन रूबी नेट :: SMTP वास्तविक HTML संदेश के रूप में एक HTML संदेश भेजने के लिए विकल्प प्रदान करता है।

ईमेल संदेश भेजते समय आप एक HTML संस्करण भेजने के लिए एक माइम संस्करण, सामग्री प्रकार और वर्ण सेट निर्दिष्ट कर सकते हैं।

उदाहरण

ईमेल के रूप में HTML सामग्री भेजने के लिए निम्नलिखित उदाहरण है। एक बार आजमा कर देखें -

require 'net/smtp'

message = <<MESSAGE_END
From: Private Person <[email protected]>
To: A Test User <[email protected]>
MIME-Version: 1.0
Content-type: text/html
Subject: SMTP e-mail test

This is an e-mail message to be sent in HTML format

<b>This is HTML message.</b>
<h1>This is headline.</h1>
MESSAGE_END

Net::SMTP.start('localhost') do |smtp|
   smtp.send_message message, '[email protected]', '[email protected]'
end

ई-मेल के रूप में अटैचमेंट भेजना

मिश्रित सामग्री के साथ एक ईमेल भेजने के लिए सेट करने की आवश्यकता होती है Content-type हेडर करने के लिए multipart/mixed। फिर पाठ और अनुलग्नक अनुभागों को निर्दिष्ट किया जा सकता हैboundaries।

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

संलग्न फ़ाइलों को इनकोड किया जाना चाहिए pack("m") ट्रांसमिशन से पहले बेस 64 एनकोडिंग का कार्य करता है।

उदाहरण

निम्नलिखित उदाहरण है, जो एक फ़ाइल भेजेगा /tmp/test.txt एक अनुलग्नक के रूप में।

require 'net/smtp'

filename = "/tmp/test.txt"
# Read a file and encode it into base64 format
filecontent = File.read(filename)
encodedcontent = [filecontent].pack("m")   # base64

marker = "AUNIQUEMARKER"
body = <<EOF
This is a test email to send an attachement.
EOF

# Define the main headers.
part1 = <<EOF
From: Private Person <[email protected]>
To: A Test User <[email protected]>
Subject: Sending Attachement
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary = #{marker}
--#{marker}
EOF

# Define the message action
part2 = <<EOF
Content-Type: text/plain
Content-Transfer-Encoding:8bit

#{body}
--#{marker}
EOF

# Define the attachment section
part3 = <<EOF
Content-Type: multipart/mixed; name = \"#{filename}\"
Content-Transfer-Encoding:base64
Content-Disposition: attachment; filename = "#{filename}"

#{encodedcontent}
--#{marker}--
EOF

mailtext = part1 + part2 + part3

# Let's put our code in safe area
begin 
   Net::SMTP.start('localhost') do |smtp|
      smtp.sendmail(mailtext, '[email protected]', ['[email protected]'])
   end
rescue Exception => e  
   print "Exception occured: " + e  
end

NOTE - आप सरणी के अंदर कई गंतव्य निर्दिष्ट कर सकते हैं लेकिन उन्हें अल्पविराम द्वारा अलग किया जाना चाहिए।

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

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

यह अध्याय आपको नेटवर्किंग - सॉकेट प्रोग्रामिंग में सबसे प्रसिद्ध अवधारणा पर एक समझ देता है।

सॉकेट्स क्या हैं?

सॉकेट्स एक द्विदिश संचार चैनल के समापन बिंदु हैं। सॉकेट्स एक प्रक्रिया के भीतर, एक ही मशीन पर प्रक्रियाओं के बीच, या विभिन्न महाद्वीपों पर प्रक्रियाओं के बीच संवाद कर सकते हैं।

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

सॉकेट्स की अपनी शब्दावली है -

अनु क्रमांक।	शब्द और विवरण
1	domain प्रोटोकॉल का परिवार जो परिवहन तंत्र के रूप में उपयोग किया जाएगा। ये मान PF_INET, PF_UNIX, PF_X25, और इतने पर जैसे स्थिरांक हैं।
2	type दो अंत बिंदुओं के बीच संचार का प्रकार, आमतौर पर कनेक्शन-उन्मुख प्रोटोकॉल के लिए SOCK_STREAM और कनेक्शन रहित प्रोटोकॉल के लिए SOCK_DGRAM।
3	protocol आमतौर पर शून्य, इसका उपयोग किसी डोमेन और प्रकार के प्रोटोकॉल के एक प्रकार की पहचान करने के लिए किया जा सकता है।
4	hostname नेटवर्क इंटरफ़ेस की पहचानकर्ता - एक स्ट्रिंग, जो होस्ट नाम, डॉटेड-क्वाड एड्रेस या कोलोन में IPV6 एड्रेस (और संभवतः डॉट) हो सकता है एक स्ट्रिंग "<प्रसारण>", जो एक INADDR_BROADCAST पते को निर्दिष्ट करता है। एक शून्य-लंबाई वाली स्ट्रिंग, जो INADDR_ANY को निर्दिष्ट करती है, या एक इंटीजर, जिसे बाइट ऑर्डर में एक बाइनरी एड्रेस के रूप में व्याख्या किया गया है।
5	port प्रत्येक सर्वर एक या अधिक पोर्ट पर कॉल करने वाले क्लाइंट के लिए सुनता है। एक पोर्ट एक Fixnum पोर्ट नंबर, एक स्ट्रिंग जिसमें पोर्ट नंबर या सेवा का नाम हो सकता है।

एक साधारण ग्राहक

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

TCPSocket.open(hosname, port )पोर्ट पर होस्टनाम के लिए एक टीसीपी कनेक्शन खोलता है ।

एक बार जब आपके पास एक सॉकेट खुला होता है, तो आप इसे किसी भी IO ऑब्जेक्ट की तरह पढ़ सकते हैं। जब किया जाता है, तो इसे बंद करना याद रखें, क्योंकि आप एक फ़ाइल बंद कर देंगे।

निम्न कोड एक बहुत ही सरल क्लाइंट है जो किसी दिए गए होस्ट और पोर्ट से जुड़ता है, सॉकेट से किसी भी उपलब्ध डेटा को पढ़ता है, और फिर इसे हटा देता है -

require 'socket'        # Sockets are in standard library

hostname = 'localhost'
port = 2000

s = TCPSocket.open(hostname, port)

while line = s.gets     # Read lines from the socket
   puts line.chop       # And print with platform line terminator
end
s.close                 # Close the socket when done

एक साधारण सर्वर

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

अब बुलाओ TCPServer.open(hostname, portअपनी सेवा के लिए एक पोर्ट निर्दिष्ट करने और बनाने के लिए फ़ंक्शनTCPServer वस्तु।

इसके बाद, दिए गए TCPServer ऑब्जेक्ट की स्वीकार विधि को कॉल करें । यह विधि तब तक प्रतीक्षा करती है जब तक कोई क्लाइंट आपके द्वारा निर्दिष्ट पोर्ट से कनेक्ट नहीं होता है, और फिर उस क्लाइंट के कनेक्शन का प्रतिनिधित्व करने वाले एक टीसीपीएसकेट ऑब्जेक्ट को लौटाता है ।

require 'socket'                 # Get sockets from stdlib

server = TCPServer.open(2000)    # Socket to listen on port 2000
loop {                           # Servers run forever
   client = server.accept        # Wait for a client to connect
   client.puts(Time.now.ctime)   # Send the time to the client
   client.puts "Closing the connection. Bye!"
   client.close                  # Disconnect from the client
}

अब, इस सर्वर को पृष्ठभूमि में चलाएं और फिर परिणाम देखने के लिए उपरोक्त क्लाइंट को चलाएं।

मल्टी-क्लाइंट टीसीपी सर्वर

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

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

require 'socket'                 # Get sockets from stdlib

server = TCPServer.open(2000)    # Socket to listen on port 2000
loop {                           # Servers run forever
   Thread.start(server.accept) do |client|
   client.puts(Time.now.ctime)   # Send the time to the client
   client.puts "Closing the connection. Bye!"
   client.close                  # Disconnect from the client
   end
}

इस उदाहरण में, आपके पास एक स्थायी लूप है, और जब server.accept प्रतिसाद देता है, तो एक नया थ्रेड बनाया जाता है और कनेक्शन को संभालने के लिए तुरंत शुरू किया जाता है, जो कि कनेक्शन ऑब्जेक्ट को थ्रेड में पारित करके उपयोग किया जाता है। हालांकि, मुख्य कार्यक्रम तुरंत वापस हो जाता है और नए कनेक्शन की प्रतीक्षा करता है।

इस तरह से रूबी थ्रेड्स का उपयोग करने का मतलब है कि कोड पोर्टेबल है और लिनक्स, ओएस एक्स और विंडोज पर उसी तरह से चलेगा।

एक छोटे वेब ब्राउज़र

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

require 'socket'
 
host = 'www.tutorialspoint.com'     # The web server
port = 80                           # Default HTTP port
path = "/index.htm"                 # The file we want 

# This is the HTTP request we send to fetch a file
request = "GET #{path} HTTP/1.0\r\n\r\n"

socket = TCPSocket.open(host,port)  # Connect to server
socket.print(request)               # Send request
response = socket.read              # Read complete response
# Split response at first blank line into headers and body
headers,body = response.split("\r\n\r\n", 2) 
print body                          # And display it

समान वेब क्लाइंट को लागू करने के लिए, आप पहले से निर्मित लाइब्रेरी का उपयोग कर सकते हैं Net::HTTPHTTP के साथ काम करने के लिए। यहाँ वह कोड है जो पिछले कोड के बराबर है -

require 'net/http'                  # The library we need
host = 'www.tutorialspoint.com'     # The web server
path = '/index.htm'                 # The file we want 

http = Net::HTTP.new(host)          # Create a connection
headers, body = http.get(path)      # Request the file
if headers.code == "200"            # Check the status code   
   print body                        
else                                
   puts "#{headers.code} #{headers.message}" 
end

कृपया एफ़टीपी, एसएमटीपी, पीओपी और आईएमएपी प्रोटोकॉल के साथ काम करने के लिए समान पुस्तकालयों की जांच करें।

आगे की रीडिंग

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

XML क्या है?

एक्स्टेंसिबल मार्कअप लैंग्वेज (एक्सएमएल) एचटीएमएल या एसजीएमएल जैसी मार्कअप भाषा है। यह वर्ल्ड वाइड वेब कंसोर्टियम द्वारा अनुशंसित है और एक खुले मानक के रूप में उपलब्ध है।

XML एक पोर्टेबल, ओपन सोर्स भाषा है जो प्रोग्रामर को उन एप्लिकेशन को विकसित करने की अनुमति देती है, जो ऑपरेटिंग सिस्टम और / या डेवलपमेंट लैंग्वेज की परवाह किए बिना अन्य एप्लिकेशन द्वारा पढ़े जा सकते हैं।

SQL- आधारित बैकबोन की आवश्यकता के बिना डेटा की छोटी से मध्यम मात्रा का ट्रैक रखने के लिए XML बेहद उपयोगी है।

XML पार्सर आर्किटेक्चर और एपीआई

XML पार्सर के लिए दो अलग-अलग स्वाद उपलब्ध हैं -

• SAX-like (Stream interfaces)- यहां आप ब्याज की घटनाओं के लिए कॉलबैक दर्ज करते हैं और फिर दस्तावेज़ के माध्यम से पार्सर को आगे बढ़ने देते हैं। यह तब उपयोगी होता है जब आपके दस्तावेज़ बड़े होते हैं या आपकी मेमोरी सीमाएँ होती हैं, यह फ़ाइल को पार्स करता है क्योंकि यह डिस्क से पढ़ता है, और पूरी फ़ाइल कभी मेमोरी में संग्रहीत नहीं होती है।

• DOM-like (Object tree interfaces) - यह वर्ल्ड वाइड वेब कंसोर्टियम की सिफारिश है जिसमें पूरी फ़ाइल को मेमोरी में पढ़ा जाता है और एक XML दस्तावेज़ की सभी विशेषताओं का प्रतिनिधित्व करने के लिए एक पदानुक्रमित (ट्री-आधारित) रूप में संग्रहीत किया जाता है।

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

SAX केवल-पढ़ने के लिए है, जबकि DOM XML फ़ाइल में परिवर्तन की अनुमति देता है। चूंकि ये दो अलग-अलग एपीआई सचमुच एक-दूसरे के पूरक हैं, इसलिए कोई कारण नहीं है कि आप बड़ी परियोजनाओं के लिए उन दोनों का उपयोग नहीं कर सकते हैं।

रूबी का उपयोग करके XML बनाना और बनाना

XML में हेरफेर करने का सबसे आम तरीका सीन रसेल द्वारा REXML लाइब्रेरी है। 2002 के बाद से, REXML मानक रूबी वितरण का हिस्सा रहा है।

आरएक्सएमएल एक शुद्ध-रूबी एक्सएमएल प्रोसेसर है जो एक्सएमएल 1.0 मानक के अनुरूप है। यह एक गैर-वैध प्रोसेसर है, सभी OASIS गैर-वैधता अनुरूपता परीक्षणों से गुजर रहा है।

REXML पार्सर के अन्य उपलब्ध पार्सर्स पर निम्नलिखित लाभ हैं -

• यह रूबी में 100 प्रतिशत लिखा है।
• इसका उपयोग SAX और DOM पार्सिंग दोनों के लिए किया जा सकता है।
• यह हल्का है, 2000 से कम लाइनों का कोड है।
• तरीके और कक्षाएं वास्तव में आसानी से समझ में आने वाली हैं।
• SAX2- आधारित एपीआई और पूर्ण XPath समर्थन।
• रूबी स्थापना के साथ भेज दिया और कोई अलग स्थापना की आवश्यकता नहीं है।

हमारे सभी XML कोड उदाहरणों के लिए, आइए इनपुट के रूप में एक सरल XML फ़ाइल का उपयोग करें -

<collection shelf = "New Arrivals">
   <movie title = "Enemy Behind">
      <type>War, Thriller</type>
      <format>DVD</format>
      <year>2003</year>
      <rating>PG</rating>
      <stars>10</stars>
      <description>Talk about a US-Japan war</description>
   </movie>
   <movie title = "Transformers">
      <type>Anime, Science Fiction</type>
      <format>DVD</format>
      <year>1989</year>
      <rating>R</rating>
      <stars>8</stars>
      <description>A schientific fiction</description>
   </movie>
   <movie title = "Trigun">
      <type>Anime, Action</type>
      <format>DVD</format>
      <episodes>4</episodes>
      <rating>PG</rating>
      <stars>10</stars>
      <description>Vash the Stampede!</description>
   </movie>
   <movie title = "Ishtar">
      <type>Comedy</type>
      <format>VHS</format>
      <rating>PG</rating>
      <stars>2</stars>
      <description>Viewable boredom</description>
   </movie>
</collection>

डोम की तरह पार्सिंग

आइए पहले ट्री स्टाइल में हमारे XML डेटा को पार्स करें । हमें आवश्यकता होती हैrexml/documentपुस्तकालय; अक्सर हम सुविधा के लिए शीर्ष-स्तरीय नाम स्थान में आयात करने के लिए REXML को शामिल करते हैं।

#!/usr/bin/ruby -w

require 'rexml/document'
include REXML

xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)

# Now get the root element
root = xmldoc.root
puts "Root element : " + root.attributes["shelf"]

# This will output all the movie titles.
xmldoc.elements.each("collection/movie"){ 
   |e| puts "Movie Title : " + e.attributes["title"] 
}

# This will output all the movie types.
xmldoc.elements.each("collection/movie/type") {
   |e| puts "Movie Type : " + e.text 
}

# This will output all the movie description.
xmldoc.elements.each("collection/movie/description") {
   |e| puts "Movie Description : " + e.text 
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Root element : New Arrivals
Movie Title : Enemy Behind
Movie Title : Transformers
Movie Title : Trigun
Movie Title : Ishtar
Movie Type : War, Thriller
Movie Type : Anime, Science Fiction
Movie Type : Anime, Action
Movie Type : Comedy
Movie Description : Talk about a US-Japan war
Movie Description : A schientific fiction
Movie Description : Vash the Stampede!
Movie Description : Viewable boredom

एसएएक्स-जैसे पार्सिंग

समान डेटा, मूवीज। Xml को प्रोसेस करने के लिए , स्ट्रीम-ओरिएंटेड तरीके से फाइल करें, हम एक श्रोता वर्ग को परिभाषित करेंगे, जिसके तरीके पार्सर से कॉलबैक का लक्ष्य होंगे ।

NOTE - यह एक छोटी फ़ाइल के लिए SAX की तरह पार्सिंग का उपयोग करने का सुझाव नहीं दिया गया है, यह सिर्फ एक डेमो उदाहरण के लिए है।

#!/usr/bin/ruby -w

require 'rexml/document'
require 'rexml/streamlistener'
include REXML

class MyListener
   include REXML::StreamListener
   def tag_start(*args)
      puts "tag_start: #{args.map {|x| x.inspect}.join(', ')}"
   end

   def text(data)
      return if data =~ /^\w*$/     # whitespace only
      abbrev = data[0..40] + (data.length > 40 ? "..." : "")
      puts "  text   :   #{abbrev.inspect}"
   end
end

list = MyListener.new
xmlfile = File.new("movies.xml")
Document.parse_stream(xmlfile, list)

यह निम्नलिखित परिणाम का उत्पादन करेगा -

tag_start: "collection", {"shelf"=>"New Arrivals"}
tag_start: "movie", {"title"=>"Enemy Behind"}
tag_start: "type", {}
   text   :   "War, Thriller"
tag_start: "format", {}
tag_start: "year", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
   text   :   "Talk about a US-Japan war"
tag_start: "movie", {"title"=>"Transformers"}
tag_start: "type", {}
   text   :   "Anime, Science Fiction"
tag_start: "format", {}
tag_start: "year", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
   text   :   "A schientific fiction"
tag_start: "movie", {"title"=>"Trigun"}
tag_start: "type", {}
   text   :   "Anime, Action"
tag_start: "format", {}
tag_start: "episodes", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
   text   :   "Vash the Stampede!"
tag_start: "movie", {"title"=>"Ishtar"}
tag_start: "type", {}
tag_start: "format", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
   text   :   "Viewable boredom"

XPath और रूबी

XML को देखने का एक वैकल्पिक तरीका XPath है। यह एक प्रकार की छद्म भाषा है जो यह बताती है कि किसी XML दस्तावेज़ में विशिष्ट तत्वों और विशेषताओं का पता कैसे लगाया जाता है, उस दस्तावेज़ को तार्किक पेड़ के रूप में माना जाता है।

REXML को XPath क्लास के माध्यम से XPath सपोर्ट है । यह पेड़ आधारित पार्सिंग (दस्तावेज़ ऑब्जेक्ट मॉडल) को मानता है जैसा कि हमने ऊपर देखा है।

#!/usr/bin/ruby -w

require 'rexml/document'
include REXML

xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)

# Info for the first movie found
movie = XPath.first(xmldoc, "//movie")
p movie

# Print out all the movie types
XPath.each(xmldoc, "//type") { |e| puts e.text }

# Get an array of all of the movie formats.
names = XPath.match(xmldoc, "//format").map {|x| x.text }
p names

यह निम्नलिखित परिणाम का उत्पादन करेगा -

<movie title = 'Enemy Behind'> ... </>
War, Thriller
Anime, Science Fiction
Anime, Action
Comedy
["DVD", "DVD", "DVD", "VHS"]

XSLT और रूबी

दो XSLT पार्सर उपलब्ध हैं जो रूबी उपयोग कर सकते हैं। प्रत्येक का संक्षिप्त विवरण यहां दिया गया है।

रूबी Sablotron

इस पार्सर को मासायोशी ताकाहाशी ने लिखा और बनाए रखा है। यह मुख्य रूप से लिनक्स ओएस के लिए लिखा गया है और इसके लिए निम्न पुस्तकालयों की आवश्यकता है -

• Sablot
• Iconv
• Expat

आप इस मॉड्यूल को पा सकते हैं Ruby-Sablotron।

XSLT4R

XSLT4R को माइकल न्यूमैन द्वारा लिखा गया है और इसे XML के तहत लाइब्रेरी अनुभाग में RAA पर पाया जा सकता है। XSLT4R एक सरल कमांडलाइन इंटरफ़ेस का उपयोग करता है, हालांकि इसे वैकल्पिक रूप से XML दस्तावेज़ को बदलने के लिए एक तृतीय-पक्ष एप्लिकेशन के भीतर उपयोग किया जा सकता है।

XSLT4R को संचालित करने के लिए XMLScan की आवश्यकता है, जो XSLT4R संग्रह में शामिल है और जो 100 प्रतिशत Rubb मॉड्यूल भी है। इन मॉड्यूल्स को स्टैंडर्ड रूबी इंस्टॉलेशन मेथड (यानी रूबी इंस्टाल.आरबी) का उपयोग करके इंस्टॉल किया जा सकता है।

XSLT4R में निम्नलिखित सिंटैक्स है -

ruby xslt.rb stylesheet.xsl document.xml [arguments]

यदि आप XSLT4R का उपयोग किसी एप्लिकेशन के भीतर से करना चाहते हैं, तो आप XSLT को शामिल कर सकते हैं और आपको आवश्यक पैरामीटर इनपुट कर सकते हैं। यहाँ उदाहरण है -

require "xslt"

stylesheet = File.readlines("stylesheet.xsl").to_s
xml_doc = File.readlines("document.xml").to_s
arguments = { 'image_dir' => '/....' }
sheet = XSLT::Stylesheet.new( stylesheet, arguments )

# output to StdOut
sheet.apply( xml_doc )

# output to 'str'
str = ""
sheet.output = [ str ]
sheet.apply( xml_doc )

आगे की पढाई

• REXML पार्सर पर संपूर्ण विवरण के लिए, कृपया REXML Parser प्रलेखन के लिए मानक प्रलेखन देखें ।

• आप XSLT4R को RAA रिपॉजिटरी से डाउनलोड कर सकते हैं ।

SOAP क्या है?

सरल ऑब्जेक्ट एक्सेस प्रोटोकॉल (SOAP), एक क्रॉस-प्लेटफ़ॉर्म और भाषा-स्वतंत्र RPC प्रोटोकॉल है जो XML पर आधारित है और आमतौर पर (लेकिन आवश्यक नहीं) HTTP है।

यह एक्सएमएल का उपयोग उन सूचनाओं को एनकोड करने के लिए करता है जो दूरस्थ प्रक्रिया को कॉल करता है, और HTTP से उस जानकारी को क्लाइंट्स से सर्वरों तक और इसके विपरीत ट्रांसपोर्ट करता है।

SOAP के अन्य तकनीकों जैसे COM, CORBA आदि पर कई फायदे हैं: उदाहरण के लिए, इसकी अपेक्षाकृत सस्ती तैनाती और डिबगिंग लागत, इसकी एक्स्टेंसिबिलिटी और आसानी का उपयोग, और विभिन्न भाषाओं और प्लेटफार्मों के लिए कई कार्यान्वयनों का अस्तित्व।

कृपया इसे विस्तार से समझने के लिए हमारे सरल ट्यूटोरियल SOAP का संदर्भ लें ।

यह अध्याय आपको रूबी (SOAP4R) के लिए SOAP कार्यान्वयन से परिचित कराता है। यह एक बुनियादी ट्यूटोरियल है, इसलिए यदि आपको एक गहन विवरण की आवश्यकता है, तो आपको अन्य संसाधनों को संदर्भित करने की आवश्यकता होगी।

SOAP4R स्थापित करना

SOAP4R हिरोशी नाकामुरा द्वारा विकसित रूबी के लिए SOAP कार्यान्वयन है और इससे डाउनलोड किया जा सकता है -

NOTE - एक महान मौका हो सकता है कि आपने पहले से ही इस घटक को स्थापित किया हो।

Download SOAP

अगर आपको पता है gem उपयोगिता तब आप SOAP4R और संबंधित पैकेजों को स्थापित करने के लिए निम्न कमांड का उपयोग कर सकते हैं।

$ gem install soap4r --include-dependencies

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

SOAP4R सर्वर लेखन

SOAP4R दो अलग-अलग प्रकार के सर्वरों का समर्थन करता है -

• CGI / FastCGI आधारित (SOAP :: RPC :: CGIStub)
• स्टैंडअलोन (SOAP :: RPC: स्टैंडअलोन सेवर)

यह अध्याय एक स्टैंड अलोन सर्वर लिखने पर विस्तार देता है। निम्नलिखित कदम एक SOAP सर्वर लिखने में शामिल हैं।

चरण 1 - इनहेरिट SOAP :: RPC :: स्टैंडअलोन सेवर क्लास

अपने खुद के योग्य स्वतंत्र सर्वर को लागू करने के लिए आप एक नया वर्ग, जिनमें से बच्चे को हो जाएगा लिखने की ज़रूरत सोप :: StandaloneServer इस प्रकार है -

class MyServer < SOAP::RPC::StandaloneServer
  ...............
end

NOTE- अगर आप FastCGI आधारित सर्वर लिखना चाहते हैं तो आपको SOAP :: RPC :: CGIStub को मूल वर्ग के रूप में लेना होगा, बाकी प्रक्रिया वही रहेगी।

चरण 2 - हैंडलर विधियों को परिभाषित करें

दूसरा कदम है अपनी वेब सेवा विधियों को लिखना, जिन्हें आप बाहरी दुनिया के सामने लाना चाहते हैं।

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

class MyServer < SOAP::RPC::StandaloneServer
   ...............

   # Handler methods
   def add(a, b)
      return a + b
   end
   def div(a, b) 
      return a / b 
   end
end

चरण 3 - हैंडलर विधियों को उजागर करें

अगला कदम हमारे सर्वर में हमारे परिभाषित तरीकों को जोड़ना है। इनिशियलाइज़ विधि दो निम्न विधियों में से एक के साथ सेवा के तरीकों का पर्दाफाश करने के लिए किया जाता है -

class MyServer < SOAP::RPC::StandaloneServer
   def initialize(*args)
      add_method(receiver, methodName, *paramArg)
   end
end

यहाँ मापदंडों का वर्णन है -

अनु क्रमांक।	पैरामीटर और विवरण
1	receiver ऑब्जेक्ट जिसमें MethodName विधि है। आप एक ही वर्ग में सेवा विधियों को मेथडिफ विधि के रूप में परिभाषित करते हैं, यह पैरामीटर स्व है ।
2	methodName उस विधि का नाम जिसे RPC अनुरोध के कारण कहा जाता है।
3	paramArg निर्दिष्ट किया जाता है, जब दिया जाता है, पैरामीटर नाम और पैरामीटर मोड।

इनआउट या आउट मापदंडों के उपयोग को समझने के लिए , निम्न सेवा विधि पर विचार करें जो दो पैरामीटर (inParam और inPParam) को लेती है, एक सामान्य रिटर्न मान (retVal) और दो और पैरामीटर: inoutParam और outParam -

def aMeth(inParam, inoutParam)
   retVal = inParam + inoutParam
   outParam = inParam . inoutParam
   inoutParam = inParam * inoutParam
   return retVal, inoutParam, outParam
end

अब, हम इस विधि को निम्नानुसार उजागर कर सकते हैं -

add_method(self, 'aMeth', [
   %w(in inParam),
   %w(inout inoutParam),
   %w(out outParam),
   %w(retval return)
])

चरण 4 - सर्वर शुरू करें

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

myServer = MyServer.new('ServerName', 'urn:ruby:ServiceName', hostname, port)

myServer.start

यहाँ आवश्यक मापदंडों का वर्णन है -

अनु क्रमांक।	पैरामीटर और विवरण
1	ServerName एक सर्वर नाम, आप जो सबसे अधिक पसंद करते हैं वह दे सकते हैं।
2	urn:ruby:ServiceName यहाँ कलश: माणिक स्थिर है लेकिन आप इस सर्वर के लिए एक अद्वितीय सेवानाम दे सकते हैं।
3	hostname होस्टनाम निर्दिष्ट करता है जिस पर यह सर्वर सुनेंगे।
4	port वेब सेवा के लिए उपलब्ध पोर्ट नंबर।

उदाहरण

अब, उपरोक्त चरणों का उपयोग करते हुए, हम एक स्टैंडअलोन सर्वर लिखते हैं -

require "soap/rpc/standaloneserver"

begin
   class MyServer < SOAP::RPC::StandaloneServer

      # Expose our services
      def initialize(*args)
         add_method(self, 'add', 'a', 'b')
         add_method(self, 'div', 'a', 'b')
      end

      # Handler methods
      def add(a, b)
         return a + b
      end
      def div(a, b) 
         return a / b 
      end
end
   server = MyServer.new("MyServer", 
            'urn:ruby:calculation', 'localhost', 8080)
   trap('INT){
      server.shutdown
   }
   server.start
rescue => err
   puts err.message
end

जब मार डाला, इस सर्वर अनुप्रयोग पर स्टैंडअलोन सोप सर्वर शुरू होता है स्थानीय होस्ट और पर अनुरोध के लिए सुनता पोर्ट 8080 यह एक सेवा के तरीकों, को उजागर करता है जोड़ने और div है, जो दो पैरामीटर लेता है और परिणाम लौटने।

अब, आप इस सर्वर को पृष्ठभूमि में इस प्रकार चला सकते हैं -

$ ruby MyServer.rb&

लेखन SOAP4R ग्राहक

सोप :: RPC :: चालक वर्ग सोप क्लाइंट अनुप्रयोग लिखने के लिए सहायता प्रदान करता है। यह अध्याय इस वर्ग का वर्णन करता है और एक अनुप्रयोग के आधार पर इसके उपयोग को प्रदर्शित करता है।

निम्नलिखित नंगे न्यूनतम जानकारी के लिए आपको SOAP सेवा पर कॉल करना होगा -

• SOAP सेवा का URL (SOAP समापन बिंदु URL)।
• सेवा विधियों के नामस्थान (विधि नामस्थान URI)।
• सेवा विधियों और उनके मापदंडों के नाम।

अब, हम एक SOAP क्लाइंट लिखेंगे जो उपरोक्त उदाहरण में परिभाषित सेवा विधियों को कॉल करेगा, जिसका नाम ऐड और डिव होगा ।

SOAP क्लाइंट बनाने के लिए यहाँ मुख्य चरण हैं।

चरण 1 - एक SOAP ड्राइवर इंस्टेंस बनाएँ

हम का एक उदाहरण बनाने सोप :: RPC :: चालक अपनी नई विधि बुला इस प्रकार से -

SOAP::RPC::Driver.new(endPoint, nameSpace, soapAction)

यहाँ आवश्यक मापदंडों का वर्णन है -

अनु क्रमांक।	पैरामीटर और विवरण
1	endPoint से कनेक्ट करने के लिए SOAP सर्वर का URL।
2	nameSpace इस SOAP :: RPC :: ड्रायवर ऑब्जेक्ट के साथ किए गए सभी RPC के लिए उपयोग करने का नामस्थान।
3	soapAction HTTP हेडर के SOAPAction फ़ील्ड का मान। यदि यह डिफॉल्ट खाली स्ट्रिंग "" के लिए है।

चरण 2 - सेवा विधियाँ जोड़ें

SOAP :: RPC :: ड्राइवर के लिए SOAP सेवा विधि जोड़ने के लिए हम SOAP :: RPC: ड्राइवर उदाहरण का उपयोग करके निम्नलिखित विधि को कॉल कर सकते हैं।

driver.add_method(name, *paramArg)

यहाँ मापदंडों का वर्णन है -

अनु क्रमांक।	पैरामीटर और विवरण
1	name दूरस्थ वेब सेवा विधि का नाम।
2	paramArg दूरस्थ प्रक्रियाओं के मापदंडों के नाम निर्दिष्ट करता है।

चरण 3 - SOAP सेवा लागू करें

अंतिम चरण SOAP :: RPC :: ड्राइवर उदाहरण का उपयोग करके SOAP सेवा को इनवॉइस करना है -

result = driver.serviceMethod(paramArg...)

यहाँ serviceMethod वास्तविक वेब सेवा विधि है और paramArg ... सेवा विधि में पारित करने के लिए आवश्यक सूची पैरामीटर है।

Example

उपरोक्त चरणों के आधार पर, हम एक SOAP क्लाइंट को निम्नानुसार लिखेंगे -

#!/usr/bin/ruby -w

require 'soap/rpc/driver'

NAMESPACE = 'urn:ruby:calculation'
URL = 'http://localhost:8080/'

begin
   driver = SOAP::RPC::Driver.new(URL, NAMESPACE)
   
   # Add remote sevice methods
   driver.add_method('add', 'a', 'b')

   # Call remote service methods
   puts driver.add(20, 30)
rescue => err
   puts err.message
end

आगे की रीडिंग

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

परिचय

रूबी के लिए मानक ग्राफिकल यूजर इंटरफेस (GUI) Tk है। Tk ने जॉन Ousterhout द्वारा विकसित Tcl स्क्रिप्टिंग भाषा के लिए GUI के रूप में शुरुआत की।

Tk को एकमात्र क्रॉस-प्लेटफ़ॉर्म GUI होने का अद्वितीय गौरव प्राप्त है। Tk विंडोज, मैक और लिनक्स पर चलता है और प्रत्येक ऑपरेटिंग सिस्टम पर एक देशी लुक-एंड-फील प्रदान करता है।

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

Tk एप्लिकेशन एक विजेट पदानुक्रम का अनुसरण करते हैं, जहां किसी भी विजेट के किसी भी नंबर को दूसरे विजेट के भीतर रखा जा सकता है, और उन विजेट को किसी अन्य विजेट, विज्ञापन इन्फिनिटम में रखा जा सकता है। Tk प्रोग्राम में मुख्य विजेट को रूट विजेट के रूप में जाना जाता है और इसे TkRoot क्लास का नया उदाहरण बनाकर बनाया जा सकता है।

• अधिकांश Tk- आधारित अनुप्रयोग एक ही चक्र का अनुसरण करते हैं: विजेट बनाएँ, उन्हें इंटरफ़ेस में रखें, और अंत में, प्रत्येक विजेट के साथ जुड़े घटनाओं को एक विधि से बांधें।

• तीन ज्यामिति प्रबंधक हैं; जगह, ग्रिड और पैक जो इंटरफ़ेस में प्रत्येक विजेट के आकार और स्थान को नियंत्रित करने के लिए जिम्मेदार हैं।

इंस्टालेशन

रूबी टीके बाइंडिंग रूबी के साथ वितरित किए जाते हैं लेकिन टीके एक अलग स्थापना है। Windows उपयोगकर्ता ActiveState के ActiveTcl से एकल क्लिक Tk इंस्टॉलेशन डाउनलोड कर सकते हैं ।

मैक और लिनक्स उपयोगकर्ताओं को इसे स्थापित करने की आवश्यकता नहीं हो सकती है क्योंकि एक बढ़िया मौका है कि इसका पहले से ही ओएस के साथ स्थापित है लेकिन यदि नहीं, तो आप प्रीबिल्ट पैकेज डाउनलोड कर सकते हैं या Tcl Developer Xchange से स्रोत प्राप्त कर सकते हैं ।

सरल टीके आवेदन

रूबी / टीके कार्यक्रमों के लिए एक विशिष्ट संरचना मुख्य या बनाने के लिए है root विंडो (TkRoot का एक उदाहरण), यूजर इंटरफेस बनाने के लिए विजेट्स को इसमें जोड़ें और फिर कॉल करके मुख्य ईवेंट लूप शुरू करें Tk.mainloop।

पारंपरिक हैलो, विश्व! रूबी / Tk के लिए उदाहरण कुछ इस तरह है -

require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
   text 'Hello, World!'
   pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop

यहां, tk एक्सटेंशन मॉड्यूल लोड करने के बाद, हम TkRoot.new का उपयोग करके एक रूट-स्तरीय फ्रेम बनाते हैं । हम तब TkLabel विजेट को रूट फ्रेम के एक बच्चे के रूप में बनाते हैं , लेबल के लिए कई विकल्प सेट करते हैं। अंत में, हम रूट फ्रेम पैक करते हैं और मुख्य GUI इवेंट लूप दर्ज करते हैं।

यदि आप इस स्क्रिप्ट को चलाते हैं, तो यह निम्नलिखित परिणाम देगा -

रूबी / टीके विजेट कक्षाएं

विभिन्न रूबी / टीके वर्गों की एक सूची है, जिसका उपयोग रूबी / टीके का उपयोग करके वांछित जीयूआई बनाने के लिए किया जा सकता है।

• TkFrame फ्रेम विजेट बनाता है और हेरफेर करता है।

• TkButton बटन विजेट बनाता है और हेरफेर करता है।

• TkLabel बनाता है और लेबल विगेट्स में हेरफेर करता है।

• TkEntry प्रविष्टि विजेट बनाता है और हेरफेर करता है।

• TkCheckButton बनाता है और चेकबटन विजेट्स में हेरफेर करता है।

• TkRadioButton रेडियोबॉटन विजेट्स को बनाता और मैनिपुलेट करता है।

• TkListbox सूची बॉक्स विजेट बनाता है और हेरफेर करता है।

• TkComboBox लिस्टबॉक्स विगेट्स बनाता है और उनमें हेरफेर करता है।

• TkMenu मेनू विजेट बनाता है और हेरफेर करता है।

• TkMenubutton Menubutton विजेट बनाता है और उसमें हेरफेर करता है।

• Tk.messageBox एक संदेश संवाद बनाता है और हेरफेर करता है।

• TkScrollbar स्क्रॉलबार विजेट बनाता है और हेरफेर करता है।

• TkCanvas कैनवास विजेट बनाता है और हेरफेर करता है।

• TkScale स्केल विजेट बनाता है और हेरफेर करता है।

• TTText टेक्स्ट विजेट बनाता है और उनमें हेरफेर करता है।

• TkToplevel क्रॉपवेल विजेट बनाता है और हेरफेर करता है।

• TkSpinbox स्पिनबॉक्स विजेट्स को बनाता और उनमें हेरफेर करता है।

• TkProgressBar प्रोग्रेस बार विजेट बनाता है और हेरफेर करता है।

• डायलॉग बॉक्स बनाता है और डायलॉग बॉक्स विजेट में हेरफेर करता है।

• Tk :: टाइल :: नोटबुक नोटबुक रूपक के साथ सीमित स्थान में कई विंडो प्रदर्शित करें।

• Tk :: टाइल :: पैन किए गए कई उप-विंडो प्रदर्शित करता है, जो खड़ी या क्षैतिज रूप से खड़ी होती हैं।

• Tk :: टाइल :: विभाजक एक क्षैतिज या ऊर्ध्वाधर विभाजक बार प्रदर्शित करता है।

• रूबी / टीके फ़ॉन्ट, रंग और छवियां समझना रूबी / टीके फ़ॉन्ट्स, रंग और छवियां

मानक विन्यास विकल्प

सभी विगेट्स में कई अलग-अलग कॉन्फ़िगरेशन विकल्प होते हैं, जो आमतौर पर नियंत्रित करते हैं कि वे कैसे प्रदर्शित होते हैं या वे कैसे व्यवहार करते हैं। जो विकल्प उपलब्ध हैं, वे निश्चित रूप से विजेट क्लास पर निर्भर हैं।

यहां सभी मानक कॉन्फ़िगरेशन विकल्पों की एक सूची है, जो किसी भी रूबी / टीके विजेट पर लागू हो सकती है।

अन्य विजेट विशिष्ट विकल्प भी हैं, जिन्हें विजेट के साथ समझाया जाएगा।

अनु क्रमांक।	विकल्प और विवरण
1	activebackground => स्ट्रिंग सक्रिय तत्वों को बनाते समय पृष्ठभूमि के रंग का उपयोग करने के लिए निर्दिष्ट करता है। एक तत्व सक्रिय है यदि माउस कर्सर को तत्व के ऊपर स्थित किया गया है और माउस बटन दबाने से कुछ क्रिया हो सकती है। आप "लाल", "नीला", "गुलाबी", "पीला" आदि जैसे रंग नामों का उपयोग कर सकते हैं।
2	activeborderwidth => पूर्णांक एक गैर-नकारात्मक मान निर्दिष्ट करता है जो सक्रिय तत्वों के आसपास खींची गई 3-डी सीमा की चौड़ाई को दर्शाता है।
3	activeforeground => स्ट्रिंग सक्रिय तत्वों को खींचते समय अग्रभूमि रंग निर्दिष्ट करता है।
4	anchor => स्ट्रिंग निर्दिष्ट करता है कि विजेट में जानकारी (जैसे पाठ या बिटमैप) को विजेट में कैसे प्रदर्शित किया जाना है। मूल्यों में से एक होना चाहिएn, ne, e, se, s, sw, w, nw, या center। उदाहरण के लिए,nw का अर्थ है कि इस तरह की जानकारी प्रदर्शित करें कि उसका ऊपरी-बाएँ कोने विजेट के ऊपरी-बाएँ कोने पर है।
5	background or bg => स्ट्रिंग विजेट प्रदर्शित करते समय सामान्य पृष्ठभूमि रंग का उपयोग करने के लिए निर्दिष्ट करता है।
6	bitmap => बिटमैप विजेट में प्रदर्शित करने के लिए एक बिटमैप निर्दिष्ट करता है। जिस तरह से बिटमैप प्रदर्शित होता है, ठीक उसी तरह से अन्य विकल्पों जैसे कि लंगर या औचित्य से प्रभावित हो सकता है।
7	borderwidth or bd => पूर्णांक विजेट के बाहर चारों ओर आकर्षित करने के लिए 3-डी सीमा की चौड़ाई को इंगित करने वाला एक गैर-नकारात्मक मूल्य निर्दिष्ट करता है।
8	compound => स्ट्रिंग निर्दिष्ट करता है कि क्या विजेट को एक ही समय में पाठ और बिटमैप / छवियां प्रदर्शित करनी चाहिए, और यदि ऐसा है, जहां पाठ के सापेक्ष बिटमैप / छवि को रखा जाना चाहिए। मूल्यों में से एक होना चाहिएnone, bottom, top, left, right, या center।
9	cursor => स्ट्रिंग विजेट के लिए उपयोग किए जाने वाले माउस कर्सर को निर्दिष्ट करता है। संभव मान "घड़ी", "तीर" आदि हो सकते हैं।
10	disabledforeground => स्ट्रिंग एक अक्षम तत्व को ड्राइंग करते समय उपयोग करने के लिए अग्रभूमि रंग निर्दिष्ट करता है।
1 1	exportselection => बूलियन निर्दिष्ट करता है कि विजेट में एक चयन भी एक्स चयन होना चाहिए या नहीं। मान किसी भी हो सकता हैtrue, false, 0, 1, yes, या no। यदि चयन का निर्यात किया जाता है, तो विजेट में चयन वर्तमान एक्स चयन को रद्द कर देता है, विजेट के बाहर चयन किसी भी विजेट चयन को रद्द कर देता है, और विजेट चयन का अनुरोध करने पर पुनः प्राप्ति अनुरोधों का जवाब देगा।
12	font => स्ट्रिंग विजेट के अंदर पाठ खींचते समय फ़ॉन्ट का उपयोग करने के लिए निर्दिष्ट करता है।
13	foreground or fg => स्ट्रिंग विजेट प्रदर्शित करते समय उपयोग करने के लिए सामान्य अग्रभूमि रंग निर्दिष्ट करता है।
14	highlightbackground => स्ट्रिंग ट्रैवर्सल हाइलाइट क्षेत्र में प्रदर्शित करने के लिए रंग निर्दिष्ट करता है जब विजेट में इनपुट फ़ोकस नहीं होता है।
15	highlightcolor => स्ट्रिंग जब यह इनपुट फ़ोकस होता है, तो विजेट के चारों ओर खींची गई ट्रैवेलर हाइलाइट आयत के लिए उपयोग करने के लिए रंग निर्दिष्ट करता है।
16	highlightthickness => पूर्णांक एक गैर-नकारात्मक मान निर्दिष्ट करता है जो कि इनपुट फोकस होने पर विजेट के बाहर के चारों ओर खींचने के लिए हाइलाइट आयत की चौड़ाई को दर्शाता है।
17	image => छवि विजेट में प्रदर्शित करने के लिए एक छवि निर्दिष्ट करता है, जो एक छवि बनाने के साथ बनाया गया होगा। आमतौर पर, यदि छवि विकल्प निर्दिष्ट किया जाता है, तो यह अन्य विकल्पों को ओवरराइड करता है जो विजेट में प्रदर्शित करने के लिए बिटमैप या पाठ मान निर्दिष्ट करते हैं; बिटमैप या पाठ प्रदर्शन को पुन: सक्षम करने के लिए छवि विकल्प एक खाली स्ट्रिंग पर रीसेट किया जा सकता है।
18	jump => स्ट्रिंग एक स्लाइडर के साथ विजेट के लिए, जो मान को समायोजित करने के लिए खींचा जा सकता है, जैसे कि स्क्रॉलबार और तराजू, यह विकल्प निर्धारित करता है जब मूल्य में बदलाव के बारे में सूचनाएं बनाई जाती हैं। विकल्प का मूल्य एक बूलियन होना चाहिए। यदि मान गलत है, तो लगातार अपडेट किए जाते हैं क्योंकि स्लाइडर को खींचा जाता है। यदि मान सत्य है, तो ड्रैग को समाप्त करने के लिए माउस बटन जारी होने तक अपडेट में देरी होती है; उस बिंदु पर एक एकल अधिसूचना की जाती है।
19	justify => स्ट्रिंग जब विजेट में टेक्स्ट की कई लाइनें प्रदर्शित होती हैं, तो यह विकल्प निर्धारित करता है कि लाइनें एक-दूसरे के साथ कैसे पंक्तिबद्ध होती हैं। में से एक होना चाहिएleft, center, या right। Left इसका मतलब है कि लाइनों के सभी किनारों को छोड़ दिया, center इसका मतलब है कि लाइनों के केंद्र संरेखित हैं, और right इसका मतलब है कि लाइनों के दाएं किनारे ऊपर हैं।
20	offset => स्ट्रिंग टाइल्स की ऑफसेट निर्दिष्ट करता है (यह भी देखें) tileविकल्प)। इसके दो अलग-अलग प्रारूप हो सकते हैंoffset x,y या offset side, जहां पक्ष हो सकता है n, ne, e, se, s, sw, w, nw, या center।
21	orient => स्ट्रिंग विगेट्स के लिए जो क्षैतिज या ऊर्ध्वाधर अभिविन्यास के साथ खुद को बाहर कर सकते हैं, जैसे स्क्रॉलबार, यह विकल्प निर्दिष्ट करता है कि किस अभिविन्यास का उपयोग किया जाना चाहिए। होना भी चाहिएhorizontal या vertical या इनमें से किसी एक का संक्षिप्त नाम।
22	padx => पूर्णांक एक्स-दिशा में विजेट के लिए अनुरोध करने के लिए कितना अतिरिक्त स्थान है यह दर्शाता है कि एक गैर-नकारात्मक मूल्य निर्दिष्ट करता है।
23	pady => पूर्णांक एक गैर-नकारात्मक मान निर्दिष्ट करता है जो दर्शाता है कि Y- दिशा में विजेट के लिए अनुरोध करने के लिए कितना अतिरिक्त स्थान है।
24	relief => पूर्णांक विजेट के लिए वांछित 3-डी प्रभाव को निर्दिष्ट करता है। स्वीकार्य मूल्य हैंraised, sunken, flat, ridge, तथा groove।
25	repeatdelay => पूर्णांक यह निर्दिष्ट करता है कि मिलिसेकंड की संख्या एक बटन या कुंजी को ऑटो-रिपीट होने से पहले नीचे आयोजित की जानी चाहिए। स्क्रॉलबार में ऊपर और नीचे-तीर पर, उदाहरण के लिए, उपयोग किया जाता है।
26	repeatinterval => पूर्णांक के साथ संयोजन के रूप में उपयोग किया जाता है repeatdelay: ऑटो-रिपीट शुरू होने के बाद, यह विकल्प ऑटो-रिपीट के बीच मिलीसेकंड की संख्या निर्धारित करता है
27	selectbackground => स्ट्रिंग चयनित आइटम प्रदर्शित करते समय पृष्ठभूमि रंग का उपयोग करने के लिए निर्दिष्ट करता है।
28	selectborderwidth => पूर्णांक गैर-नकारात्मक मान निर्दिष्ट करता है जो चयनित आइटमों को खींचने के लिए 3-डी सीमा की चौड़ाई का संकेत देता है।
29	selectforeground => स्ट्रिंग चयनित आइटम प्रदर्शित करते समय उपयोग करने के लिए अग्रभूमि रंग निर्दिष्ट करता है।
30	setgrid => बूलियन एक बूलियन मान निर्दिष्ट करता है जो यह निर्धारित करता है कि क्या यह विजेट अपने शीर्ष-स्तरीय विंडो के लिए आकार बदलने वाले ग्रिड को नियंत्रित करता है। यह विकल्प आम तौर पर टेक्स्ट विजेट्स में उपयोग किया जाता है, जहां विजेट में जानकारी का एक प्राकृतिक आकार (एक चरित्र का आकार) होता है और यह विंडो के आयामों को इन इकाइयों का अभिन्न नंबर होने के लिए समझ में आता है।
31	takefocus => पूर्णांक कीबोर्ड ट्रैवर्सल (जैसे, टैब और शिफ्ट-टैब) के माध्यम से खिड़की से खिड़की पर ध्यान केंद्रित करते समय उपयोग की जाने वाली जानकारी प्रदान करता है। विंडो पर फ़ोकस सेट करने से पहले, ट्रैवर्सल स्क्रिप्ट पहले यह देख लेती हैं कि विंडो देखने योग्य है (यह और इसके सभी पूर्वजों को मैप किया गया है); यदि नहीं, तो खिड़की छोड़ दी जाती है। 0 के मान का अर्थ है कि यह विंडो पूरी तरह से कीबोर्ड ट्रैवर्सल के दौरान छोड़ दी जानी चाहिए। 1 का मतलब है कि इस विंडो को हमेशा इनपुट फोकस प्राप्त करना चाहिए।
32	text => स्ट्रिंग विजेट के अंदर प्रदर्शित होने के लिए एक स्ट्रिंग निर्दिष्ट करता है। जिस तरह से स्ट्रिंग प्रदर्शित किया जाता है वह विशेष विजेट पर निर्भर करता है और अन्य विकल्पों द्वारा निर्धारित किया जा सकता है, जैसे किanchor या justify।
33	textvariable => चर एक चर का नाम निर्दिष्ट करता है। चर का मान विजेट के अंदर प्रदर्शित होने के लिए एक पाठ स्ट्रिंग है; यदि वैरिएबल मान बदलता है, तो नए मूल्य को दर्शाने के लिए विजेट अपने आप अपडेट हो जाएगा। विजेट में स्ट्रिंग को जिस तरह से प्रदर्शित किया गया है, वह विशेष विजेट पर निर्भर करता है और अन्य विकल्पों, जैसे कि, द्वारा निर्धारित किया जा सकता हैanchor या justify।
34	tile => छवि विजेट प्रदर्शित करने के लिए उपयोग की गई छवि निर्दिष्ट करता है। यदि छवि खाली स्ट्रिंग है, तो सामान्य पृष्ठभूमि का रंग प्रदर्शित किया जाता है।
35	troughcolor => स्ट्रिंग स्क्रॉलबार्स और स्केल जैसे विगेट्स में आयताकार गर्त क्षेत्रों के लिए उपयोग करने के लिए रंग निर्दिष्ट करता है।
36	troughtile => छवि स्क्रॉलबार्स और स्केल जैसे विगेट्स में आयताकार गर्त क्षेत्रों में प्रदर्शित करने के लिए उपयोग की जाने वाली छवि को निर्दिष्ट करता है।
37	underline => पूर्णांक विजेट में रेखांकित करने के लिए एक वर्ण के पूर्णांक सूचकांक को निर्दिष्ट करता है। यह विकल्प डिफ़ॉल्ट बाइंडिंग द्वारा मेनू बटन और मेनू प्रविष्टियों के लिए कीबोर्ड ट्रैवर्सल को लागू करने के लिए उपयोग किया जाता है। 0 विजेट में प्रदर्शित पाठ के पहले चरित्र से मेल खाता है, 1 से अगले चरित्र तक, और इसी तरह।
38	wraplength => पूर्णांक विगेट्स के लिए जो वर्ड-रैपिंग कर सकते हैं, यह विकल्प अधिकतम लाइन लंबाई निर्दिष्ट करता है।
39	xscrollcommand => कार्य क्षैतिज स्क्रॉलबार के साथ संचार करने के लिए उपयोग किए जाने वाले कॉलबैक को निर्दिष्ट करता है।
40	yscrollcommand => कार्य वर्टिकल स्क्रॉलबार के साथ संचार करने के लिए उपयोग किए जाने वाले कॉलबैक को निर्दिष्ट करता है।

रूबी / टीके ज्यामिति प्रबंधन

ज्यामिति प्रबंधन आवश्यकता के अनुसार विभिन्न विजेट्स की स्थिति से संबंधित है। टीके में ज्यामिति प्रबंधन मास्टर और दास विगेट्स की अवधारणा पर निर्भर करता है।

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

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

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

• ग्रिड ज्यामिति प्रबंधक जो एक ग्रिड में विगेट्स की व्यवस्था करता है।

• पैक ज्यामिति प्रबंधक पैक के आसपास गुहा के किनारों कि।

• जगह निश्चित या रबर शीट प्लेसमेंट के लिए ज्यामिति प्रबंधक।

रूबी / टीके इवेंट हैंडलिंग

रूबी / टीके इवेंट लूप का समर्थन करता है , जो ऑपरेटिंग सिस्टम से घटनाओं को प्राप्त करता है। ये बटन प्रेस, कीस्ट्रोक, माउस मूवमेंट, विंडो का आकार बदलना, इत्यादि जैसी चीजें हैं।

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

उच्च स्तर पर, रूबी / टीके आपके प्रोग्राम में कॉलबैक को आमंत्रित करता है ताकि यह इंगित किया जा सके कि विजेट के लिए कुछ महत्वपूर्ण हुआ है या तो मामले के लिए, आप एक कोड ब्लॉक या एक रूबी प्रोक ऑब्जेक्ट प्रदान कर सकते हैं जो यह निर्दिष्ट करता है कि एप्लिकेशन ईवेंट या कॉलबैक पर प्रतिक्रिया कैसे देता है।

आइए एक नज़र डालते हैं कि बुनियादी विंडो सिस्टम घटनाओं को रूबी प्रक्रियाओं से जोड़ने के लिए बाइंड पद्धति का उपयोग कैसे करें। बाइंड का सबसे सरल रूप इसके इनपुट के रूप में लेता है जो घटना के नाम और एक कोड ब्लॉक का संकेत देता है जिसे Tk ईवेंट को संभालने के लिए उपयोग करता है।

उदाहरण के लिए, कुछ विजेट पर पहले माउस बटन के लिए ButtonRelease घटना को पकड़ने के लिए, आप लिखेंगे -

someWidget.bind('ButtonRelease-1') {
   ....code block to handle this event...
}

एक इवेंट नाम में अतिरिक्त संशोधक और विवरण शामिल हो सकते हैं। एक संशोधक शिफ्ट , नियंत्रण या Alt की तरह एक स्ट्रिंग है , यह दर्शाता है कि एक संशोधक कुंजी दबाया गया था।

इसलिए, उदाहरण के लिए, उपयोगकर्ता द्वारा Ctrl कुंजी को दबाए रखने पर उत्पन्न होने वाली घटना को पकड़ने और सही माउस बटन पर क्लिक करने के लिए।

someWidget.bind('Control-ButtonPress-3', proc { puts "Ouch!" })

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

helpButton = TkButton.new(buttonFrame) {
   text "Help"
   command proc { showHelp }
}

या विजेट की कमांड विधि का उपयोग करके आप इसे बाद में असाइन कर सकते हैं -

helpButton.command proc { showHelp }

चूंकि कमांड विधि या तो प्रक्रियाओं या कोड ब्लॉक को स्वीकार करती है, आप पिछले कोड उदाहरण को भी लिख सकते हैं -

helpButton = TkButton.new(buttonFrame) {
   text "Help"
   command { showHelp }
}

आप अपने रूबी / टीके आवेदन में निम्नलिखित मूल घटना प्रकारों का उपयोग कर सकते हैं -

अनु क्रमांक।	टैग और घटना विवरण
1	"1" (one) बाईं माउस बटन पर क्लिक किया।
2	"ButtonPress-1" बाईं माउस बटन पर क्लिक किया।
3	"Enter" मूषक अंदर चला गया।
4	"Leave" मूषक बाहर चला गया।
5	"Double-1" डबल क्लिक किया गया।
6	"B3-Motion" दायां बटन एक स्थिति से दूसरे स्थान पर खींचें।
7	Control-ButtonPress-3 Ctrl कुंजी के साथ दायां बटन दबाया जाता है ।
8	Alt-ButtonPress-1 बटन को Alt Key के साथ दबाया जाता है ।

कॉन्फ़िगर विधि

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

require "tk"

button = TkButton.new {
   text 'Hello World!'
   pack
}
button.configure('activebackground', 'blue')
Tk.mainloop

एक वर्तमान विजेट के लिए मान प्राप्त करने के लिए, बस इसे निम्नानुसार मूल्य के बिना आपूर्ति करें -

color = button.configure('activebackground')

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

The Cget Method

केवल एक विकल्प के मूल्य को पुनः प्राप्त करने के लिए, आम तौर पर आप चाहते हैं की तुलना में अधिक जानकारी कॉन्फ़िगर करें। Cget पद्धति अभी वर्तमान मान लौटाती है।

color = button.cget('activebackground')

रूबी / LDAP रूबी के लिए एक विस्तार पुस्तकालय है। यह कुछ LDAP पुस्तकालयों जैसे OpenLDAP, UMich LDAP, नेटस्केप SDK, ActiveDirectory को इंटरफ़ेस प्रदान करता है।

अनुप्रयोग विकास के लिए सामान्य एपीआई RFC1823 में वर्णित है और रूबी / LDAP द्वारा समर्थित है।

रूबी / LDAP स्थापना

आप SOURCEFORGE.NET से एक पूर्ण रूबी / LDAP पैकेज डाउनलोड और स्थापित कर सकते हैं ।

रूबी / LDAP स्थापित करने से पहले, सुनिश्चित करें कि आपके पास निम्नलिखित घटक हैं -

• रूबी 1.8.x (यदि आप ldap / नियंत्रण का उपयोग करना चाहते हैं तो कम से कम 1.8.2)।
• OpenLDAP, नेटस्केप एसडीके, विंडोज 2003 या विंडोज एक्सपी।

अब, आप मानक रूबी स्थापना विधि का उपयोग कर सकते हैं। शुरू करने से पहले, यदि आप extconf.rb के लिए उपलब्ध विकल्प देखना चाहते हैं, तो इसे '--help' विकल्प के साथ चलाएं।

$ ruby extconf.rb [--with-openldap1|--with-openldap2| \
                   --with-netscape|--with-wldap32]
$ make $ make install

NOTE- यदि आप Windows पर सॉफ्टवेयर का निर्माण कर रहे हैं, तो आप उपयोग करना पड़ सकता nmake के बजाय मेकअप ।

LDAP कनेक्शन स्थापित करें

यह दो चरणों वाली प्रक्रिया है -

चरण 1 - कनेक्शन ऑब्जेक्ट बनाएँ

LDAP निर्देशिका से संबंध बनाने के लिए सिंटैक्स निम्नलिखित है।

LDAP::Conn.new(host = 'localhost', port = LDAP_PORT)

• host- यह होस्ट आईडी है जो LDAP डायरेक्टरी चला रही है। हम इसे लोकलहोस्ट के रूप में लेंगे ।

• port- यह LDAP सेवा के लिए उपयोग किया जा रहा पोर्ट है। मानक LDAP पोर्ट 636 और 389 हैं। सुनिश्चित करें कि आपके सर्वर पर किस पोर्ट का उपयोग किया जा रहा है अन्यथा आप LDAP :: LDAP_PORT का उपयोग कर सकते हैं।

यह कॉल एक नया LDAP :: सर्वर से कनेक्शन, होस्ट , पोर्ट पोर्ट पर देता है ।

चरण 2 - बंधन

यह वह जगह है जहां हम आमतौर पर उपयोगकर्ता नाम और पासवर्ड निर्दिष्ट करते हैं जो हम शेष सत्र के लिए उपयोग करेंगे।

DN का उपयोग करते हुए LDAP कनेक्शन को बाँधने के लिए सिंटैक्स निम्नलिखित है, dn, साख, pwd, और बाइंड विधि, method -

conn.bind(dn = nil, password = nil, method = LDAP::LDAP_AUTH_SIMPLE)do
....
end

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

conn.bind(dn = nil, password = nil, method = LDAP::LDAP_AUTH_SIMPLE)
....
conn.unbind

यदि एक कोड ब्लॉक दिया जाता है, तो स्वयं को ब्लॉक में निकाला जाता है।

हम अब बाइंड विधि (बाइंड और अनइंड के बीच) के ब्लॉक के अंदर खोज, जोड़, संशोधित या हटा सकते हैं, बशर्ते हमारे पास उचित अनुमति हो।

Example

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

#/usr/bin/ruby -w

require 'ldap'

$HOST = 'localhost' $PORT =    LDAP::LDAP_PORT
$SSLPORT = LDAP::LDAPS_PORT conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')
....
conn.unbind

एक LDAP प्रविष्टि जोड़ना

LDPA प्रविष्टि जोड़ना दो चरणों वाली प्रक्रिया है -

चरण 1 - LDAP बनाना :: आधुनिक वस्तु

हमें एक प्रविष्टि बनाने के लिए LDAP :: mod ऑब्जेक्ट पास को con.add विधि की आवश्यकता है। यहाँ LDAP बनाने के लिए एक सरल वाक्यविन्यास है :: आधुनिक वस्तु -

Mod.new(mod_type, attr, vals)

• mod_type - एक या अधिक विकल्प LDAP_MOD_ADD, LDAP_MOD_REPLACE या LDAP_MOD_DELETE।

• attr - उस विशेषता का नाम होना चाहिए जिस पर काम करना है।

• vals- attr से संबंधित मूल्यों की एक सरणी है । यदि Vals बाइनरी डेटा है, mod_type तार्किक OR'ed किया जाना चाहिए (|) LDAP_MOD_BVALUES साथ।

यह कॉल LDAP :: मॉड ऑब्जेक्ट को लौटाता है , जिसे LDAP :: CON वर्ग, जैसे कि कॉन # ऐड, कॉन # add_ext, कॉन # मॉडिफ़ाइड और कॉन # मॉडिफ़ाइ_टैक में तरीकों से पास किया जा सकता है।

चरण 2 - कॉलिंग con.add विधि

एक बार जब हम LDAP :: मॉड ऑब्जेक्ट के साथ तैयार होते हैं , तो हम एक प्रविष्टि बनाने के लिए con.add विधि कह सकते हैं । यहाँ इस पद्धति को कॉल करने के लिए एक वाक्यविन्यास है -

conn.add(dn, attrs)

इस विधि डीएन, के साथ एक प्रवेश कहते हैं dn , और विशेषताओं, attrs । यहां, अटार्स में एलडीएपी की एक सरणी होनी चाहिए :: मॉड ऑब्जेक्ट या विशेषता / मूल्य सरणी जोड़े का एक हैश।

Example

यहाँ एक पूर्ण उदाहरण है, जो दो निर्देशिका प्रविष्टियाँ बनाएगा -

#/usr/bin/ruby -w

require 'ldap'

$HOST =    'localhost'
$PORT = LDAP::LDAP_PORT $SSLPORT = LDAP::LDAPS_PORT

conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')

conn.perror("bind")
entry1 = [
   LDAP.mod(LDAP::LDAP_MOD_ADD,'objectclass',['top','domain']),
   LDAP.mod(LDAP::LDAP_MOD_ADD,'o',['TTSKY.NET']),
   LDAP.mod(LDAP::LDAP_MOD_ADD,'dc',['localhost']),
]

entry2 = [
   LDAP.mod(LDAP::LDAP_MOD_ADD,'objectclass',['top','person']),
   LDAP.mod(LDAP::LDAP_MOD_ADD, 'cn', ['Zara Ali']),
   LDAP.mod(LDAP::LDAP_MOD_ADD | LDAP::LDAP_MOD_BVALUES, 'sn', 
                     ['ttate','ALI', "zero\000zero"]),
]

begin
   conn.add("dc = localhost, dc = localdomain", entry1)
   conn.add("cn = Zara Ali, dc = localhost, dc =  localdomain", entry2)
rescue LDAP::ResultError
   conn.perror("add")
   exit
end
conn.perror("add")
conn.unbind

LDAP प्रविष्टि को संशोधित करना

प्रविष्टि को संशोधित करना एक जोड़ने के समान है। संशोधित करने के लिए विशेषताओं के साथ जोड़ने के बजाय बस संशोधित विधि को कॉल करें । यहाँ संशोधित विधि का एक सरल वाक्यविन्यास है ।

conn.modify(dn, mods)

यह विधि DN, dn , और विशेषताओं, mods के साथ एक प्रविष्टि को संशोधित करती है । इधर, mods या तो की एक सरणी होना चाहिए LDAP :: मॉड वस्तुओं या विशेषता / मान सरणी जोड़े के हैश।

उदाहरण

प्रविष्टि के उपनाम को संशोधित करने के लिए, जिसे हमने पिछले अनुभाग में जोड़ा था, हम लिखेंगे -

#/usr/bin/ruby -w

require 'ldap'

$HOST = 'localhost' $PORT =    LDAP::LDAP_PORT
$SSLPORT = LDAP::LDAPS_PORT conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')

conn.perror("bind")
entry1 = [
   LDAP.mod(LDAP::LDAP_MOD_REPLACE, 'sn', ['Mohtashim']),
]

begin
   conn.modify("cn = Zara Ali, dc = localhost, dc = localdomain", entry1)
rescue LDAP::ResultError
   conn.perror("modify")
   exit
end
conn.perror("modify")
conn.unbind

एक LDAP प्रविष्टि हटाना

प्रविष्टि को हटाने के लिए, पैरामीटर के रूप में प्रतिष्ठित नाम के साथ डिलीट विधि को कॉल करें । यहां डिलीट मेथड का सिंपल सिंटैक्स दिया गया है ।

conn.delete(dn)

यह विधि DN, dn के साथ एक प्रविष्टि को हटा देती है ।

उदाहरण

ज़ारा मोहताशिम प्रविष्टि को हटाने के लिए , जिसे हमने पिछले भाग में जोड़ा था, हम लिखेंगे -

#/usr/bin/ruby -w

require 'ldap'

$HOST =    'localhost'
$PORT = LDAP::LDAP_PORT $SSLPORT = LDAP::LDAPS_PORT

conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')

conn.perror("bind")
begin
   conn.delete("cn = Zara-Mohtashim, dc = localhost, dc = localdomain")
rescue LDAP::ResultError
   conn.perror("delete")
   exit
end
conn.perror("delete")
conn.unbind

विशिष्ट नाम को संशोधित करना

संशोधित विधि के साथ प्रविष्टि के विशिष्ट नाम को संशोधित करना संभव नहीं है । इसके बजाय, मॉड्रन विधि का उपयोग करें । यहाँ मॉडर्न विधि का सरल वाक्य विन्यास है -

conn.modrdn(dn, new_rdn, delete_old_rdn)

यह विधि DN, dn के साथ प्रविष्टि के RDN को संशोधित करती है , इसे नया RDN, new_rdn देता है । यदि delete_old_rdn है सच , वर्ष RDN मूल्य प्रविष्टि से हटा दिया जाएगा।

उदाहरण

मान लें कि हमारे पास निम्नलिखित प्रविष्टि है -

dn: cn = Zara Ali,dc = localhost,dc = localdomain
cn: Zara Ali
sn: Ali
objectclass: person

फिर, हम निम्नलिखित कोड के साथ इसके विशिष्ट नाम को संशोधित कर सकते हैं -

#/usr/bin/ruby -w

require 'ldap'

$HOST = 'localhost' $PORT =    LDAP::LDAP_PORT
$SSLPORT = LDAP::LDAPS_PORT conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')

conn.perror("bind")
begin
   conn.modrdn("cn = Zara Ali, dc = localhost, dc = localdomain", "cn = Zara Mohtashim", true)
rescue LDAP::ResultError
   conn.perror("modrdn")
   exit
end
conn.perror("modrdn")
conn.unbind

खोज करना

LDAP निर्देशिका पर खोज करने के लिए, तीन अलग-अलग खोज विधियों में से किसी एक के साथ खोज विधि का उपयोग करें -

• LDAP_SCOPE_BASEM - केवल आधार नोड खोजें।

• LDAP_SCOPE_ONELEVEL - आधार नोड के सभी बच्चों को खोजें।

• LDAP_SCOPE_SUBTREE - आधार नोड सहित पूरे उपशीर्षक को खोजें।

उदाहरण

यहाँ, हम व्यक्ति वस्तुओं के लिए प्रविष्टि dc = localhost, dc = localdomain के पूरे उपशीर्षक को खोजने जा रहे हैं -

#/usr/bin/ruby -w

require 'ldap'

$HOST =    'localhost'
$PORT = LDAP::LDAP_PORT $SSLPORT = LDAP::LDAPS_PORT

base = 'dc = localhost,dc = localdomain'
scope = LDAP::LDAP_SCOPE_SUBTREE
filter = '(objectclass = person)'
attrs = ['sn', 'cn']

conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')

conn.perror("bind")
begin
   conn.search(base, scope, filter, attrs) { |entry|
      # print distinguished name
      p entry.dn
      # print all attribute names
      p entry.attrs
      # print values of attribute 'sn'
      p entry.vals('sn')
      # print entry as Hash
      p entry.to_hash
   }
rescue LDAP::ResultError
   conn.perror("search")
   exit
end
conn.perror("search")
conn.unbind

यह प्रत्येक मिलान प्रविष्टि के लिए दिए गए कोड ब्लॉक को आमंत्रित करता है जहां LDAP प्रविष्टि LDAP :: प्रविष्टि वर्ग के एक उदाहरण द्वारा दर्शाई जाती है। खोज के अंतिम पैरामीटर के साथ, आप उन विशेषताओं को निर्दिष्ट कर सकते हैं जिनमें आप रुचि रखते हैं, अन्य सभी को छोड़ कर। यदि आप यहाँ nil पास करते हैं, तो सभी विशेषताओं को रिलेशनल डेटाबेस में "SELECT *" के समान ही लौटाया जाता है।

LDAP की dn विधि (get_dn के लिए उपनाम) :: प्रविष्टि वर्ग प्रविष्टि का प्रतिष्ठित नाम देता है, और to_hash विधि के साथ, आप इसकी विशेषताओं (प्रतिष्ठित नाम सहित) का हैश प्रतिनिधित्व प्राप्त कर सकते हैं। एक प्रविष्टि की विशेषताओं की एक सूची प्राप्त करने के लिए, अटार्स विधि (get_attributes के लिए उपनाम) का उपयोग करें। इसके अलावा, एक विशिष्ट विशेषता के मूल्यों की सूची प्राप्त करने के लिए, वैल विधि (get_values ​​के लिए उपनाम) का उपयोग करें।

त्रुटियों को संभालना

रूबी / LDAP दो अलग-अलग अपवाद वर्गों को परिभाषित करती है -

• त्रुटि के मामले में, नए, बाइंड या अनबाइंड विधियाँ LDAP :: त्रुटि अपवाद को बढ़ाती हैं।

• LDAP निर्देशिका जोड़ने, संशोधित करने, हटाने या खोजने के मामले में, LDAP :: ResultError बढ़ाएँ।

आगे की पढाई

LDAP विधियों पर संपूर्ण विवरण के लिए, कृपया LDAP दस्तावेज़ीकरण के लिए मानक दस्तावेज़ देखें ।

पारंपरिक कार्यक्रमों के निष्पादन के एक ही सूत्र में कथन या निर्देश शामिल होते हैं जो प्रोग्राम को समाप्त होने तक क्रमिक रूप से निष्पादित करते हैं।

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

रूबी थ्रेड क्लास के साथ बहु-थ्रेडेड प्रोग्राम लिखना आसान बनाता है । रूबी धागे अपने कोड में संगामिति प्राप्त करने के लिए एक हल्का और कुशल तरीका है।

रूबी थ्रेड बनाना

एक नया धागा शुरू करने के लिए, बस एक ब्लॉक को Thread.new पर कॉल करें । ब्लॉक में कोड निष्पादित करने के लिए एक नया थ्रेड बनाया जाएगा, और थ्रेड थ्रेड से तुरंत वापस आएगा और अगले स्टेटमेंट के साथ निष्पादन फिर से शुरू करेगा -

# Thread #1 is running here
Thread.new {
   # Thread #2 runs this code
}
# Thread #1 runs this code

उदाहरण

यहां एक उदाहरण है, जो दिखाता है कि हम बहु-थ्रेडेड रूबी प्रोग्राम का उपयोग कैसे कर सकते हैं।

#!/usr/bin/ruby

def func1
   i = 0
   while i<=2
      puts "func1 at: #{Time.now}"
      sleep(2)
      i = i+1
   end
end

def func2
   j = 0
   while j<=2
      puts "func2 at: #{Time.now}"
      sleep(1)
      j = j+1
   end
end

puts "Started At #{Time.now}"
t1 = Thread.new{func1()}
t2 = Thread.new{func2()}
t1.join
t2.join
puts "End at #{Time.now}"

यह निम्नलिखित परिणाम देगा -

Started At Wed May 14 08:21:54 -0700 2008
func1 at: Wed May 14 08:21:54 -0700 2008
func2 at: Wed May 14 08:21:54 -0700 2008
func2 at: Wed May 14 08:21:55 -0700 2008
func1 at: Wed May 14 08:21:56 -0700 2008
func2 at: Wed May 14 08:21:56 -0700 2008
func1 at: Wed May 14 08:21:58 -0700 2008
End at Wed May 14 08:22:00 -0700 2008

धागा जीवनचक्र

थ्रेड.न्यू के साथ एक नया थ्रेड बनाया जाता है । आप समानार्थी शब्द Thread.start और Thread.fork का भी उपयोग कर सकते हैं ।

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

थ्रेड क्लास चलने के दौरान थ्रेड को क्वेरी और हेरफेर करने के लिए कई तरीकों को परिभाषित करता है। थ्रेड में एक थ्रेड कोड को कॉल से संबंधित चलाता है। फिर वह चलना बंद कर देता है।

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

क्लास विधि Thread.current वर्तमान थ्रेड का प्रतिनिधित्व करने वाली थ्रेड ऑब्जेक्ट देता है। इससे धागे खुद को हेरफेर करने की अनुमति देते हैं। थ्रेडमेन को क्लास विधि मुख्य ऑब्जेक्ट का प्रतिनिधित्व करने वाले थ्रेड ऑब्जेक्ट देता है। यह निष्पादन का प्रारंभिक धागा है जो रूबी कार्यक्रम शुरू होने पर शुरू हुआ था।

आप उस थ्रेड के Thread.join विधि को कॉल करके किसी विशेष थ्रेड के समाप्त होने की प्रतीक्षा कर सकते हैं । कॉलिंग थ्रेड तब तक ब्लॉक रहेगा जब तक कि दिया गया धागा समाप्त नहीं हो जाता।

सूत्र और अपवाद

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

अगर एक धागा t एक अखंड अपवाद के कारण बाहर निकलता है, और एक और धागा sकॉल t.join या t.value, तो अपवाद है कि में हुईt धागे में उठाया जाता है s।

यदि Thread.abort_on_exception है झूठे , डिफ़ॉल्ट हालत, एक बिना क्रिया का अपवाद केवल वर्तमान धागा मारता है और सभी बाकी चलाने के लिए जारी।

यदि आप किसी भी थ्रेड में किसी भी अनहेल्दी अपवाद को चाहते हैं, तो दुभाषिया से बाहर निकलने का कारण बन सकता है, क्लास विधि Thread.abort_on_exception को सही पर सेट करें ।

t = Thread.new { ... }
t.abort_on_exception = true

धागा चर

एक धागा आम तौर पर किसी भी चर का उपयोग कर सकता है जो कि गुंजाइश तब होती है जब धागा बनाया जाता है। किसी थ्रेड के ब्लॉक के लिए चर स्थानीय थ्रेड के लिए स्थानीय होते हैं, और साझा नहीं किए जाते हैं।

थ्रेड क्लास में एक विशेष सुविधा है जो थ्रेड-लोकल वैरिएबल को नाम से बनाने और एक्सेस करने की सुविधा देती है। आप बस थ्रेड ऑब्जेक्ट का इलाज करते हैं जैसे कि यह एक हैश था, [] = का उपयोग करने वाले तत्वों को लिख रहा है और उन्हें [] का उपयोग करके वापस पढ़ रहा है।

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

#!/usr/bin/ruby

count = 0
arr = []

10.times do |i|
   arr[i] = Thread.new {
      sleep(rand(0)/10.0)
      Thread.current["mycount"] = count
      count += 1
   }
end

arr.each {|t| t.join; print t["mycount"], ", " }
puts "count = #{count}"

यह निम्न परिणाम उत्पन्न करता है -

8, 0, 3, 7, 2, 1, 6, 5, 4, 9, count = 10

मुख्य थ्रेड खत्म होने का इंतजार करता है और फिर प्रत्येक द्वारा कैप्चर की गई गणना के मूल्य को प्रिंट करता है ।

सूत्र प्राथमिकताएँ

थ्रेड शेड्यूलिंग को प्रभावित करने वाला पहला कारक थ्रेड प्राथमिकता है: उच्च-प्राथमिकता वाले थ्रेड्स को कम-प्राथमिकता वाले थ्रेड्स से पहले शेड्यूल किया जाता है। अधिक सटीक रूप से, एक थ्रेड को केवल CPU समय मिलेगा यदि कोई उच्च प्राथमिकता वाले थ्रेड्स चलाने के लिए इंतजार नहीं कर रहे हैं।

आप रूबी थ्रेड ऑब्जेक्ट की प्राथमिकता को प्राथमिकता = और प्राथमिकता के साथ सेट और क्वेरी कर सकते हैं । एक नया बनाया गया धागा उसी प्राथमिकता पर शुरू होता है जिस धागे ने उसे बनाया है। मुख्य धागा प्राथमिकता 0 पर शुरू होता है।

चलने से पहले किसी थ्रेड की प्राथमिकता निर्धारित करने का कोई तरीका नहीं है। हालाँकि, थ्रेड अपनी पहली प्राथमिकता के रूप में अपनी प्राथमिकता को बढ़ा या घटा सकता है।

धागा बहिष्कार

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

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

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

मटेक्स के बिना उदाहरण

#!/usr/bin/ruby
require 'thread'

count1 = count2 = 0
difference = 0
counter = Thread.new do
   loop do
      count1 += 1
      count2 += 1
   end
end
spy = Thread.new do
   loop do
      difference += (count1 - count2).abs
   end
end
sleep 1
puts "count1 :  #{count1}"
puts "count2 :  #{count2}"
puts "difference : #{difference}"

यह निम्नलिखित परिणाम का उत्पादन करेगा -

count1 :  1583766
count2 :  1583766
difference : 0

#!/usr/bin/ruby
require 'thread'
mutex = Mutex.new

count1 = count2 = 0
difference = 0
counter = Thread.new do
   loop do
      mutex.synchronize do
         count1 += 1
         count2 += 1
      end
   end
end
spy = Thread.new do
   loop do
      mutex.synchronize do
         difference += (count1 - count2).abs
      end
   end
end
sleep 1
mutex.lock
puts "count1 :  #{count1}"
puts "count2 :  #{count2}"
puts "difference : #{difference}"

यह निम्नलिखित परिणाम का उत्पादन करेगा -

count1 :  696591
count2 :  696591
difference : 0

गतिरोध से निपटने

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

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

उदाहरण

#!/usr/bin/ruby
require 'thread'
mutex = Mutex.new

cv = ConditionVariable.new
a = Thread.new {
   mutex.synchronize {
      puts "A: I have critical section, but will wait for cv"
      cv.wait(mutex)
      puts "A: I have critical section again! I rule!"
   }
}

puts "(Later, back at the ranch...)"

b = Thread.new {
   mutex.synchronize {
      puts "B: Now I am critical, but am done with cv"
      cv.signal
      puts "B: I am still critical, finishing up"
   }
}
a.join
b.join

यह निम्नलिखित परिणाम का उत्पादन करेगा -

A: I have critical section, but will wait for cv
(Later, back at the ranch...)
B: Now I am critical, but am done with cv
B: I am still critical, finishing up
A: I have critical section again! I rule!

थ्रेड स्टेट्स

निम्नलिखित तालिका में दिखाए गए अनुसार पांच संभव राज्यों के अनुरूप पांच संभावित रिटर्न मान हैं। स्थिति विधि थ्रेड की स्थिति देता है।

धागा राज्य	प्रतिलाभ की मात्रा
runnable	Daud
सोया हुआ	सोया हुआ
निरस्त	निरस्त
सामान्य रूप से समाप्त	असत्य
अपवाद के साथ समाप्त हुआ	शून्य

थ्रेड क्लास के तरीके

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

Thread.abort_on_exception = true

यहाँ उपलब्ध सभी वर्ग विधियों की पूरी सूची है -

अनु क्रमांक।	तरीके और विवरण
1	Thread.abort_on_exception अपवाद स्थिति पर वैश्विक गर्भपात की स्थिति लौटाता है । डिफ़ॉल्ट गलत है । जब सही पर सेट किया जाता है , तो सभी थ्रेड्स गर्भपात का कारण बनेंगे (यदि प्रक्रिया किसी भी थ्रेड में अपवाद उठाया जाता है, तो यह (0) निकल जाएगा)
2	Thread.abort_on_exception= जब सही पर सेट किया जाता है , तो अपवाद होने पर सभी धागे निरस्त हो जाएंगे। नया राज्य लौटाता है।
3	Thread.critical वैश्विक धागे की स्थिति को गंभीर स्थिति में लौटाता है ।
4	Thread.critical= वैश्विक थ्रेड की स्थिति को गंभीर स्थिति सेट करता है और उसे लौटाता है। जब सही पर सेट किया जाता है , तो किसी मौजूदा थ्रेड के शेड्यूलिंग को प्रतिबंधित करता है। नए थ्रेड्स को बनने और चलाने से ब्लॉक नहीं करता है। कुछ थ्रेड ऑपरेशन (जैसे किसी थ्रेड को रोकना या मारना, वर्तमान थ्रेड में सोना और अपवाद उठाना) किसी महत्वपूर्ण सेक्शन में भी थ्रेड को शेड्यूल किया जा सकता है।
5	Thread.current वर्तमान में निष्पादित थ्रेड लौटाता है।
6	Thread.exit वर्तमान में चल रहे थ्रेड को टर्मिनेट करता है और दूसरे थ्रेड को शेड्यूल करता है। यदि यह थ्रेड पहले से ही मारा गया है, तो थ्रेड से बाहर निकलें । यदि यह मुख्य धागा है, या अंतिम धागा है, तो प्रक्रिया से बाहर निकलें।
7	Thread.fork { block } थ्रेड.न्यू का पर्यायवाची।
8	Thread.kill( aThread ) दिए गए धागे को बाहर निकलने का कारण बनता है
9	Thread.list सभी थ्रेड्स के लिए थ्रेड ऑब्जेक्ट्स की एक सरणी देता है जो या तो रन करने योग्य हैं या बंद हो गए हैं। थ्रेड।
10	Thread.main प्रक्रिया के लिए मुख्य सूत्र देता है।
1 1	Thread.new( [ arg ]* ) {| args | block } ब्लॉक में दिए गए निर्देशों को निष्पादित करने के लिए एक नया धागा बनाता है, और इसे चलाना शुरू करता है। Thread.new में दिए गए किसी भी तर्क को ब्लॉक में पारित किया गया है।
12	Thread.pass थ्रेड शेड्यूलर को किसी अन्य थ्रेड को निष्पादन पास करने के लिए आमंत्रित करता है।
13	Thread.start( [ args ]* ) {| args | block } मूल रूप से थ्रेड.न्यू के समान है । हालाँकि, यदि क्लास थ्रेड को उप-वर्गित किया जाता है, तो उस उप-वर्ग में कॉलिंग शुरू करने से उप-वर्ग की इनिशियलाइज़ विधि नहीं होगी ।
14	Thread.stop वर्तमान थ्रेड के निष्पादन को रोक देता है, इसे एक नींद की स्थिति में डालता है , और दूसरे थ्रेड के निष्पादन को शेड्यूल करता है। झूठा करने के लिए गंभीर स्थिति रीसेट करता है ।

थ्रेड इंस्टेंस के तरीके

ये विधियाँ एक सूत्र के उदाहरण पर लागू होती हैं। इन विधियों को एक थ्रेड के उदाहरण के रूप में निम्नानुसार बुलाया जाएगा -

#!/usr/bin/ruby

thr = Thread.new do   # Calling a class method new
   puts "In second thread"
   raise "Raise exception"
end
thr.join   # Calling an instance method join

यहाँ उपलब्ध सभी उदाहरण विधियों की पूरी सूची है -

अनु क्रमांक।	तरीके और विवरण
1	thr[ aSymbol ] गुण का संदर्भ - एक थ्रेड-लोकल वैरिएबल का मान लौटाता है, या तो एक सिंबल या anSymbol नाम का उपयोग करके । यदि निर्दिष्ट चर मौजूद नहीं है, तो शून्य लौटाता है ।
2	thr[ aSymbol ] = एट्रिब्यूट असाइनमेंट - एक प्रतीक या एक स्ट्रिंग का उपयोग करके थ्रेड-लोकल वैरिएबल का मान सेट या बनाता है।
3	thr.abort_on_exception रिटर्न की स्थिति अपवाद पर बीच में बंद करें के लिए शर्त thr । डिफ़ॉल्ट गलत है ।
4	thr.abort_on_exception= करने के लिए सेट करते हैं सच है, अगर एक अपवाद में उठाया है निरस्त करने के लिए (मुख्य कार्यक्रम सहित) सभी धागे का कारण बनता है thr । प्रक्रिया प्रभावी रूप से बाहर निकल जाएगी (0) ।
5	thr.alive? रिटर्न सच अगर thr चल रहे हैं या सो रही है।
6	thr.exit समाप्त thr और कार्यक्रम एक और धागा चलाने के लिए। यदि यह थ्रेड पहले से ही मारा गया है, तो थ्रेड से बाहर निकलें । यदि यह मुख्य धागा है, या अंतिम धागा, प्रक्रिया से बाहर निकलता है।
7	thr.join कॉलिंग थ्रेड निष्पादन को निलंबित करेगा और थ्रोड चलाएगा । थ्रोट एक्सिट तक वापस नहीं आता है। मुख्य कार्यक्रम से बाहर निकलने पर शामिल नहीं होने वाले किसी भी धागे को मार दिया जाएगा।
8	thr.key? रिटर्न सच अगर दिए गए स्ट्रिंग (या चिह्न) एक धागे की स्थानीय चर के रूप में मौजूद है।
9	thr.kill के लिए पर्याय Thread.exit ।
10	thr.priority रिटर्न की प्राथमिकता thr । डिफ़ॉल्ट शून्य है; उच्च-प्राथमिकता वाले धागे निचले प्राथमिकता वाले धागे से पहले चलेंगे।
1 1	thr.priority= एक पूर्णांक के लिए सिंहासन की प्राथमिकता निर्धारित करता है। उच्च प्राथमिकता वाले धागे निचले प्राथमिकता वाले धागे से पहले चलेंगे।
12	thr.raise( anException ) से एक अपवाद को जन्म देती है thr । कॉल करने वाले को थ्रोट नहीं होना चाहिए ।
13	thr.run जाग thr , यह समय निर्धारण के लिए योग्य बना रही है। यदि एक महत्वपूर्ण खंड में नहीं है, तो अनुसूचक को आमंत्रित करता है।
14	thr.safe_level रिटर्न के लिए प्रभाव में सुरक्षित स्तर thr ।
15	thr.status रिटर्न की स्थिति thr : नींद अगर thr सो रहा है या पर आई / ओ इंतजार कर, चलाने यदि thr निष्पादित हो रहा है, झूठी अगर thr सामान्य रूप से समाप्त हो गया, और नहीं के बराबर है, तो thr एक अपवाद के साथ समाप्त हो गया।
16	thr.stop? रिटर्न सच अगर thr मृत या नींद की है।
17	thr.value Thr.join के माध्यम से पूरा करने के लिए इंतजार कर रहा है और इसके मूल्य देता है।
18	thr.wakeup मार्क्स thr निर्धारण के लिए पात्र के रूप में, यह अभी भी पर मैं / हे अवरोधित ही सकता है, तथापि।

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

आपके संदर्भ के लिए बिल्ट-इन फंक्शंस की पूरी सूची यहां दी गई है -

अनु क्रमांक।	तरीके और विवरण
1	abort कार्यक्रम को समाप्त करता है। यदि कोई अपवाद उठाया गया है (यानी, $! शून्य नहीं), तो इसका त्रुटि संदेश प्रदर्शित होता है।
2	Array( obj) रिटर्न to_ary या to_a का उपयोग करके इसे सरणी में परिवर्तित करने के बाद देता है।
3	at_exit {...} कार्यक्रम से बाहर निकलने पर निष्पादन के लिए एक ब्लॉक पंजीकृत करता है। END कथन के समान, लेकिन END कथन केवल एक बार ब्लॉक को पंजीकृत करता है।
4	autoload( classname, file) पहली बार उपयोग किए जाने वाले फ़ाइल से लोड होने के लिए एक वर्ग classname पंजीकृत करता है। classname एक स्ट्रिंग या एक प्रतीक हो सकता है।
5	binding वर्तमान चर और विधि बाइंडिंग लौटाता है। बाइंडिंग उद्देश्य यह है कि लौटा दिया जाता है करने के लिए पारित किया जा सकता eval अपनी दूसरी तर्क के रूप में विधि।
6	block_given? यदि कोई ब्लॉक के साथ विधि को कॉल किया गया था, तो सत्य है ।
7	callcc {| c|...} ब्लॉक के लिए एक कंटीन्यूएशन ऑब्जेक्ट पास करता है और ब्लॉक को निष्पादित करता है। callcc का उपयोग वैश्विक निकास या लूप निर्माण के लिए किया जा सकता है।
8	caller([ n]) प्रपत्र फ़ाइल में स्ट्रिंग्स के एक सरणी में वर्तमान निष्पादन स्टैक लौटाता है : पंक्ति । यदि n निर्दिष्ट है, तो नीचे की ओर nth स्तर से स्टैक प्रविष्टियाँ लौटाता है।
9	catch( tag) {...} अपने ब्लॉक के निष्पादन के दौरान कहे जाने वाले थ्रो द्वारा गैर-निकास निकास पकड़ता है।
10	chomp([ rs = $/]) चर का मान लौटाता है $_ with the ending newline removed, assigning the result back to $_। न्यूलाइन स्ट्रिंग का मान rs के साथ निर्दिष्ट किया जा सकता है।
1 1	chomp!([ rs = $/]) $ _ से न्यूलाइन हटाता है, स्ट्रिंग को जगह में संशोधित करता है।
12	chop का मान लौटाता है $_ with its last character (one byte) removed, assigning the result back to $_।
13	chop! $ _ से अंतिम वर्ण हटाता है, स्ट्रिंग को जगह में संशोधित करता है।
14	eval( str[, scope[, file, line]]) कार्यान्वित str रूबी कोड के रूप में। जिसमें मूल्यांकन करने के लिए बंधन को गुंजाइश के साथ निर्दिष्ट किया जा सकता है । कोड का फ़ाइल नाम और लाइन नंबर फ़ाइल और लाइन का उपयोग करके निर्दिष्ट किया जा सकता है ।
15	exec( cmd[, arg...]) कमांड cmd चलाकर वर्तमान प्रक्रिया को बदल देता है । यदि कई तर्क निर्दिष्ट किए जाते हैं, तो कमांड को शेल विस्तार के साथ निष्पादित किया जाता है।
16	exit([ result = 0]) परिणाम कोड के साथ, प्रोग्राम से बाहर निकलता है ।
17	exit!([ result = 0]) एग्ज़िट हैंडलिंग जैसे कि सुनिश्चित करना आदि को दरकिनार कर प्रोग्राम को मारता है ।
18	fail(...) देखें बढ़ाएँ (...)
19	Float( obj) रिटर्न एक नाव में परिवर्तित करने के बाद obj। संख्यात्मक वस्तुओं को सीधे रूपांतरित किया जाता है; नील को 0.0 में परिवर्तित किया जाता है; तार 0x, 0b मूलांक उपसर्ग को देखते हुए परिवर्तित किए जाते हैं। बाकी का उपयोग obj.to_f का उपयोग करके किया जाता है।
20	fork fork {...} बाल प्रक्रिया बनाता है। एनआईएल को चाइल्ड प्रोसेस में वापस कर दिया जाता है और चाइल्ड प्रोसेस की आईडी (पूर्णांक) को पेरेंट प्रोसेस में लौटा दिया जाता है। यदि कोई ब्लॉक निर्दिष्ट है, तो यह चाइल्ड प्रोसेस में चलाया जाता है।
21	format( fmt[, arg...]) स्प्रिंट देखें।
22	gets([ rs = $/]) कमांड लाइन या मानक इनपुट से एक लाइन में निर्दिष्ट फ़ाइल नाम पढ़ता है। रिकॉर्ड विभाजक स्ट्रिंग को rs के साथ स्पष्ट रूप से निर्दिष्ट किया जा सकता है।
23	global_variables वैश्विक चर नामों की एक सरणी देता है।
24	gsub( x, y) gsub( x) {...} एक्स में मिलान वाले सभी तारों को बदल देता है $_ with y. If a block is specified, matched strings are replaced with the result of the block. The modified result is assigned to $_।
25	gsub!( x, y) gsub!( x) {...} Gsub के समान प्रतिस्थापन करता है, सिवाय इसके स्ट्रिंग को जगह में बदल दिया जाता है।
26	Integer( obj) रिटर्न एक पूर्णांक में परिवर्तित करने के बाद obj। संख्यात्मक वस्तुओं को सीधे रूपांतरित किया जाता है; नील को 0 में परिवर्तित किया जाता है; तार 0x, 0b मूलांक उपसर्ग को देखते हुए परिवर्तित किए जाते हैं। बाकी को obj.to_i का उपयोग करके परिवर्तित किया जाता है।
27	lambda {| x|...} proc {| x|...} lambda प्रोक ब्लॉक को एक Proc ऑब्जेक्ट में परिवर्तित करता है । यदि कोई ब्लॉक निर्दिष्ट नहीं है, तो कॉलिंग विधि से जुड़ा ब्लॉक परिवर्तित हो जाता है।
28	load( file[, private = false]) फ़ाइल से एक रूबी प्रोग्राम लोड करता है । आवश्यकता के विपरीत , यह विस्तार पुस्तकालयों को लोड नहीं करता है। तो निजी है सच , कार्यक्रम एक गुमनाम मॉड्यूल में लोड किया जाता है, इस प्रकार बुला कार्यक्रम का नाम स्थान की रक्षा।
29	local_variables स्थानीय चर नामों की एक सरणी देता है।
30	loop {...} कोड का एक ब्लॉक दोहराता है।
31	open( path[, mode = "r"]) open( path[, mode = "r"]) {| f|...} एक फाइल खोलता है । यदि कोई ब्लॉक निर्दिष्ट किया गया है, तो ब्लॉक को एक तर्क के रूप में पारित स्ट्रीम के साथ निष्पादित किया जाता है। ब्लॉक से बाहर निकलते ही फाइल अपने आप बंद हो जाती है। यदि पथ एक पाइप से शुरू होता है |, निम्न स्ट्रिंग को कमांड के रूप में चलाया जाता है, और उस प्रक्रिया से जुड़ी धारा वापस आ जाती है।
32	p( obj) अपने निरीक्षण विधि (अक्सर डिबगिंग के लिए उपयोग किया जाता है) का उपयोग करके ओब्ज प्रदर्शित करता है।
33	print([ arg...]) प्रिंट $ डीफट करने के लिए तर्क देते हैं । यदि कोई तर्क निर्दिष्ट नहीं किया जाता है, तो $ _ का मूल्य मुद्रित होता है।
34	printf( fmt[, arg...]) प्रारूप के अनुसार ARG FMT का उपयोग कर sprintf और करने के लिए परिणाम प्रिंट $ defout । विनिर्देशों को प्रारूपित करने के लिए, विस्तार के लिए स्प्रिंट देखें।
35	proc {| x|...} proc See lamda.
36	putc( c) Prints one character to the default output ($defout).
37	puts([ str]) Prints string to the default output ($defout). If the string doesn't end with a newline, a newline is appended to the string.
38	raise(...) fail(...) Raises an exception. Assumes RuntimeError if no exception class is specified. Calling raise without arguments in a rescue clause re-raises the exception. Doing so outside a rescue clause raises a message-less RuntimeError. fail is an obsolete name for raise.
39	rand([ max = 0]) Generates a pseudo-random number greater than or equal to 0 and less than max. If max is either not specified or is set to 0, a random number is returned as a floating-point number greater than or equal to 0 and less than 1. srand may be used to initialize pseudo-random stream.
40	readline([ rs = $/]) Equivalent to gets except it raises an EOFError exception on reading EOF.
41	readlines([ rs = $/]) Returns an array of strings holding either the filenames specified as command-line arguments or the contents of standard input.
42	require( lib) Loads the library (including extension libraries) lib when it's first called. require will not load the same library more than once. If no extension is specified in lib, require tries to add .rb,.so, etc., to it.
43	scan( re) scan( re) {|x|...} Equivalent to $_.scan.
44	select( reads[, writes = nil[, excepts = nil[, timeout = nil]]]) Checks for changes in the status of three types of IO objects input, output, and exceptions which are passed as arrays of IO objects. nil is passed for arguments that don't need checking. A three-element array containing arrays of the IO objects for which there were changes in status is returned. nil is returned on timeout.
45	set_trace_func( proc) Sets a handler for tracing. proc may be a string or proc object. set_trace_func is used by the debugger and profiler.
46	sleep([ sec]) Suspends program execution for sec seconds. If sec isn't specified, the program is suspended forever.
47	split([ sep[, max]]) Equivalent to $_.split.
48	sprintf( fmt[, arg...]) format( fmt[, arg...]) Returns a string in which arg is formatted according to fmt. Formatting specifications are essentially the same as those for sprintf in the C programming language. Conversion specifiers (% followed by conversion field specifier) in fmt are replaced by formatted string of corresponding argument. A list of conversion filed is given below in next section.
49	srand([ seed]) Initializes an array of random numbers. If seed isn't specified, initialization is performed using the time and other system information for the seed.
50	String( obj) Returns obj after converting it to a string using obj.to_s.
51	syscall( sys[, arg...]) Calls an operating system call function specified by number sys. The numbers and meaning of sys is system-dependant.
52	system( cmd[, arg...]) Executes cmd as a call to the command line. If multiple arguments are specified, the command is run directly with no shell expansion. Returns true if the return status is 0 (success).
53	sub( x, y) sub( x) {...} Replaces the first string matching x in $_ with y. If a block is specified, matched strings are replaced with the result of the block. The modified result is assigned to $_.
54	sub!( x, y) sub!( x) {...} Performs the same replacement as sub, except the string is changed in place.
55	test( test, f1[, f2]) Performs various file tests specified by the character test. In order to improve readability, you should use File class methods (for example File::readable?) rather than this function. A list of arguments is given below in next section.
56	throw( tag[, value = nil]) Jumps to the catch function waiting with the symbol or string tag. value is the return value to be used by catch.
57	trace_var( var, cmd) trace_var( var) {...} Sets tracing for a global variable. The variable name is specified as a symbol. cmd may be a string or Proc object.
58	trap( sig, cmd) trap( sig) {...} Sets a signal handler. sig may be a string (like SIGUSR1) or an integer. SIG may be omitted from signal name. Signal handler for EXIT signal or signal number 0 is invoked just before process termination.
59	untrace_var( var[, cmd]) Removes tracing for a global variable. If cmd is specified, only that command is removed.

Functions for Numbers

Here is a list of Built-in Functions related to number. They should be used as follows −

#!/usr/bin/ruby

num = 12.40
puts num.floor      # 12
puts num + 10       # 22.40
puts num.integer?   # false  as num is a float.

This will produce the following result −

12
22.4
false

Assuming, n is a number −

Sr.No.	Methods & Description
1	n + num n - num n * num n / num Performs arithmetic operations: addition, subtraction, multiplication, and division.
2	n % num Returns the modulus of n.
3	n ** num Exponentiation.
4	n.abs Returns the absolute value of n.
5	n.ceil Returns the smallest integer greater than or equal to n.
6	n.coerce( num) Returns an array containing num and n both possibly converted to a type that allows them to be operated on mutually. Used in automatic type conversion in numeric operators.
7	n.divmod( num) Returns an array containing the quotient and modulus from dividing n by num.
8	n.floor Returns the largest integer less than or equal to n.
9	n.integer? Returns true if n is an integer.
10	n.modulo( num) Returns the modulus obtained by dividing n by num and rounding the quotient with floor
11	n.nonzero? Returns n if it isn't zero, otherwise nil.
12	n.remainder( num) Returns the remainder obtained by dividing n by num and removing decimals from the quotient. The result and n always have same sign.
13	n.round Returns n rounded to the nearest integer.
14	n.truncate Returns n as an integer with decimals removed.
15	n.zero? Returns zero if n is 0.
16	n & num n | num n ^ num Bitwise operations: AND, OR, XOR, and inversion.
17	n << num n >> num Bitwise left shift and right shift.
18	n[num] Returns the value of the numth bit from the least significant bit, which is n[0].
19	n.chr Returns a string containing the character for the character code n.
20	n.next n.succ Returns the next integer following n. Equivalent to n + 1.
21	n.size Returns the number of bytes in the machine representation of n.
22	n.step( upto, step) {|n| ...} Iterates the block from n to upto, incrementing by step each time.
23	n.times {|n| ...} Iterates the block n times.
24	n.to_f Converts n into a floating point number. Float conversion may lose precision information.
25	n.to_int Returns n after converting into interger number.

Functions for Float

Here is a list of Ruby Built-in functions especially for float numbers. Assuming we have a float number f −

Sr.No.	Methods & Description
1	Float::induced_from(num) Returns the result of converting num to a floating-point number.
2	f.finite? Returns true if f isn't infinite and f.nan is false.
3	f.infinite? Returns 1 if f is positive infinity, -1 if negative infinity, or nil if anything else.
4	f.nan? Returns true if f isn't a valid IEEE floating point number.

Functions for Math

Here is a list of Ruby Built-in math functions −

Sr.No.	Methods & Description
1	atan2( x, y) Calculates the arc tangent.
2	cos( x) Calculates the cosine of x.
3	exp( x) Calculates an exponential function (e raised to the power of x).
4	frexp( x) Returns a two-element array containing the nominalized fraction and exponent of x.
5	ldexp( x, exp) Returns the value of x times 2 to the power of exp.
6	log( x) Calculates the natural logarithm of x.
7	log10( x) Calculates the base 10 logarithm of x.
8	sin( x) Calculates the sine of x.
9	sqrt( x) Returns the square root of x. x must be positive.
10	tan( x) Calculates the tangent of x.

Conversion Field Specifier

The function sprintf( fmt[, arg...]) and format( fmt[, arg...]) returns a string in which arg is formatted according to fmt. Formatting specifications are essentially the same as those for sprintf in the C programming language. Conversion specifiers (% followed by conversion field specifier) in fmt are replaced by formatted string of corresponding argument.

The following conversion specifiers are supported by Ruby's format −

Sr.No.	Specifier & Description
1	b Binary integer
2	c Single character
3	d,i Decimal integer
4	e Exponential notation (e.g., 2.44e6)
5	E Exponential notation (e.g., 2.44E6)
6	f Floating-point number (e.g., 2.44)
7	g use %e if exponent is less than -4, %f otherwise
8	G use %E if exponent is less than -4, %f otherwise
9	o Octal integer
10	s String or any object converted using to_s
11	u Unsigned decimal integer
12.	x Hexadecimal integer (e.g., 39ff)
13	X Hexadecimal integer (e.g., 39FF)

Following is the usage example −

#!/usr/bin/ruby

str = sprintf("%s\n", "abc")   # => "abc\n" (simplest form)
puts str 

str = sprintf("d=%d", 42)      # => "d=42" (decimal output)
puts str 

str = sprintf("%04x", 255)     # => "00ff" (width 4, zero padded)
puts str 

str = sprintf("%8s", "hello")  # => " hello" (space padded)
puts str 

str = sprintf("%.2s", "hello") # => "he" (trimmed by precision)
puts str

This will produce the following result −

abc
d = 42
00ff
   hello
he

Test Function Arguments

The function test( test, f1[, f2]) performs one of the following file tests specified by the character test. In order to improve readability, you should use File class methods (for example, File::readable?) rather than this function.

Here are the file tests with one argument −

Sr.No.	Argument & Description
1	?r Is f1 readable by the effective uid of caller?
2	?w Is f1 writable by the effective uid of caller?
3	?x Is f1 executable by the effective uid of caller?
4	?o Is f1 owned by the effective uid of caller?
5	?R Is f1 readable by the real uid of caller?
6	?W Is f1 writable by the real uid of caller?
7	?X Is f1 executable by the real uid of caller?
8	?O Is f1 owned by the real uid of caller?
9	?e Does f1 exist?
10	?z Does f1 have zero length?
11	?s File size of f1(nil if 0)
12	?f Is f1 a regular file?
13	?d Is f1 a directory?
14	?l Is f1 a symbolic link?
15	?p Is f1 a named pipe (FIFO)?
16	?S Is f1 a socket?
17	?b Is f1 a block device?
18	?c Is f1 a character device?
19	?u Does f1 have the setuid bit set?
20	?g Does f1 have the setgid bit set?
21	?k Does f1 have the sticky bit set?
22	?M Last modification time for f1.
23	?A Last access time for f1.
24	?C Last inode change time for f1.

File tests with two arguments are as follows −

Sr.No.	Argument & Description
1	?= Are modification times of f1 and f2 equal?
2	?> Is the modification time of f1 more recent than f2 ?
3	?< Is the modification time of f1 older than f2 ?
4	?- Is f1 a hard link to f2 ?

Following is the usage example. Assuming main.rb exist with read, write and not execute permissions −

#!/usr/bin/ruby

puts test(?r, "main.rb" )   # => true
puts test(?w, "main.rb" )   # => true
puts test(?x, "main.rb" )   # => false

This will produce the following result −

true
false
false

Ruby - Predefined Variables

Ruby's predefined variables affect the behavior of the entire program, so their use in libraries is not recommended.

The values in most predefined variables can be accessed by alternative means.

Following table lists all the Ruby's predefined variables.

Sr.No.	Variable Name & Description
1	$! The last exception object raised. The exception object can also be accessed using => in rescue clause.
2	$@ The stack backtrace for the last exception raised. The stack backtrace information can retrieved by Exception#backtrace method of the last exception.
3	$/ The input record separator (newline by default). gets, readline, etc., take their input record separator as optional argument.
4	$\ The output record separator (nil by default).
5	$, The output separator between the arguments to print and Array#join (nil by default). You can specify separator explicitly to Array#join.
6	$; The default separator for split (nil by default). You can specify separator explicitly for String#split.
7	$. The number of the last line read from the current input file. Equivalent to ARGF.lineno.
8	$< Synonym for ARGF.
9	$> Synonym for $defout.
10	$0 The name of the current Ruby program being executed.
11	$$ The process pid of the current Ruby program being executed.
12	$? The exit status of the last process terminated.
13	$: Synonym for $LOAD_PATH.
14	$DEBUG True if the -d or --debug command-line option is specified.
15	$defout The destination output for print and printf ($stdout by default).
16	$F The variable that receives the output from split when -a is specified. This variable is set if the -a command-line option is specified along with the -p or -n option.
17	$FILENAME The name of the file currently being read from ARGF. Equivalent to ARGF.filename.
18	$LOAD_PATH An array holding the directories to be searched when loading files with the load and require methods.
19	$SAFE The security level 0 → No checks are performed on externally supplied (tainted) data. (default) 1 → Potentially dangerous operations using tainted data are forbidden. 2 → Potentially dangerous operations on processes and files are forbidden. 3 → All newly created objects are considered tainted. 4 → Modification of global data is forbidden.
20	$stdin Standard input (STDIN by default).
21	$stdout Standard output (STDOUT by default).
22	$stderr Standard error (STDERR by default).
23	$VERBOSE True if the -v, -w, or --verbose command-line option is specified.
24	$- x The value of interpreter option -x (x=0, a, d, F, i, K, l, p, v). These options are listed below
25	$-0 The value of interpreter option -x and alias of $/.
26	$-a The value of interpreter option -x and true if option -a is set. Read-only.
27	$-d The value of interpreter option -x and alias of $DEBUG
28	$-F The value of interpreter option -x and alias of $;.
29	$-i The value of interpreter option -x and in in-place-edit mode, holds the extension, otherwise nil. Can enable or disable in-place-edit mode.
30	$-I The value of interpreter option -x and alias of $:.
31	$-l The value of interpreter option -x and true if option -lis set. Read-only.
32	$-p The value of interpreter option -x and true if option -pis set. Read-only.
33	$_ The local variable, last string read by gets or readline in the current scope.
34	$~ The local variable, MatchData relating to the last match. Regex#match method returns the last match information.
35	$ n ($1, $2, $3...) The string matched in the nth group of the last pattern match. Equivalent to m[n], where m is a MatchData object.
36	$& The string matched in the last pattern match. Equivalent to m[0], where m is a MatchData object.
37	$` The string preceding the match in the last pattern match. Equivalent to m.pre_match, where m is a MatchData object.
38	$' The string following the match in the last pattern match. Equivalent to m.post_match, where m is a MatchData object.
39	$+ The string corresponding to the last successfully matched group in the last pattern match.

Ruby - Predefined Constants

The following table lists all the Ruby's Predefined Constants −

NOTE − TRUE, FALSE, and NIL are backward-compatible. It's preferable to use true, false, and nil.

Sr.No.	Constant Name & Description
1	TRUE Synonym for true.
2	FALSE Synonym for false.
3	NIL Synonym for nil.
4	ARGF An object providing access to virtual concatenation of files passed as command-line arguments or standard input if there are no command-line arguments. A synonym for $<.
5	ARGV An array containing the command-line arguments passed to the program. A synonym for $*.
6	DATA An input stream for reading the lines of code following the __END__ directive. Not defined if __END__ isn't present in code.
7	ENV A hash-like object containing the program's environment variables. ENV can be handled as a hash.
8	RUBY_PLATFORM A string indicating the platform of the Ruby interpreter.
9	RUBY_RELEASE_DATE A string indicating the release date of the Ruby interpreter
10	RUBY_VERSION A string indicating the version of the Ruby interpreter.
11	STDERR Standard error output stream. Default value of $stderr.
12	STDIN Standard input stream. Default value of $stdin.
13	STDOUT Standard output stream. Default value of $stdout.
14	TOPLEVEL_BINDING A binding object at Ruby's top level.

Ruby - Associated Tools

Standard Ruby Tools

The standard Ruby distribution contains useful tools along with the interpreter and standard libraries −

These tools help you debug and improve your Ruby programs without spending much effort. This tutorial will give you a very good start with these tools.

• RubyGems −

  RubyGems is a package utility for Ruby, which installs Ruby software packages and keeps them up-to-date.

• Ruby Debugger −

  To help deal with bugs, the standard distribution of Ruby includes a debugger. This is very similar to gdb utility, which can be used to debug complex programs.

• Interactive Ruby (irb) −

  irb (Interactive Ruby) was developed by Keiju Ishitsuka. It allows you to enter commands at the prompt and have the interpreter respond as if you were executing a program. irb is useful to experiment with or to explore Ruby.

• Ruby Profiler −

  Ruby profiler helps you to improve the performance of a slow program by finding the bottleneck.

Additional Ruby Tools

There are other useful tools that don't come bundled with the Ruby standard distribution. However, you do need to install them yourself.

• eRuby: Embeded Ruby −

  eRuby stands for embedded Ruby. It's a tool that embeds fragments of Ruby code in other files, such as HTML files similar to ASP, JSP and PHP.

• ri: Ruby Interactive Reference −

  When you have a question about the behavior of a certain method, you can invoke ri to read the brief explanation of the method.

For more information on Ruby tool and resources, have a look at Ruby Useful Resources.