I/O का अर्थ है इनपुट/आउटपुट।
इनपुट से हमारा तात्पर्य उस सभी डेटा और जानकारी से है जो किसी चीज़ में आती है (कंप्यूटर, रूबी मेथड, आपका दिमाग)।
इनपुट के उदाहरण:
- कीबोर्ड पर आपके द्वारा दबाई गई कीज़
- माउस क्लिक
- आपके द्वारा पढ़ी गई किताबें
आउटपुट से हमारा तात्पर्य उस हर चीज़ से है जो इनपुट के परिणामस्वरूप बाहर आती है।
आउटपुट के उदाहरण:
- 1 + 1 का परिणाम
- आपके द्वारा पढ़े गए लेख का सारांश लिखना
- कॉफी
रूबी में, जब हम I/O के बारे में बात करते हैं तो हम आमतौर पर फाइलें पढ़ने, नेटवर्क सॉकेट्स के साथ काम करने और स्क्रीन पर जानकारी प्रिंट करने का उल्लेख करते हैं।
IO क्लास को समझना
IO रूबी में एक क्लास भी है।
यह File और Socket जैसे अन्य ऑब्जेक्ट्स के लिए पैरेंट क्लास है।
सभी IO ऑब्जेक्ट्स में ये ऑपरेशन होते हैं:
- open / close
- read
- write
IO ऑब्जेक्ट्स फाइल डिस्क्रिप्टर्स पर आधारित हैं।
आपके कंप्यूटर में चल रही हर प्रोसेस की एक आंतरिक सूचना टेबल होती है।
इस टेबल का हिस्सा फाइल डिस्क्रिप्टर्स की एक सूची शामिल करता है।
एक फाइल डिस्क्रिप्टर एक पूर्णांक और एक फाइल नाम के बीच मैपिंग है।
आप लिनक्स में फाइल डिस्क्रिप्टर्स की इस सूची को देख सकते हैं।
इस कमांड के साथ:
# Assuming you have irb open on another window ls -lh /proc/`pgrep irb`/fd/ # lrwx------ 1 jesus jesus 64 Feb 3 15:54 0 -> /dev/pts/3 # lrwx------ 1 jesus jesus 64 Feb 3 15:54 1 -> /dev/pts/3 # lrwx------ 1 jesus jesus 64 Feb 3 15:54 2 -> /dev/pts/3
आप रूबी में sysopen मेथड के साथ एक नया फाइल डिस्क्रिप्टर बना सकते हैं।
उदाहरण:
fd = IO.sysopen('/dev/null', 'w') # 10
अब आप इस फाइल डिस्क्रिप्टर (10) के साथ एक कम्युनिकेशन चैनल खोल सकते हैं।
इस तरह:
io = IO.new(fd)
और इसमें लिखें:
io << 'orange'
ध्यान दें कि IO को परवाह नहीं है कि आपका फाइल डिस्क्रिप्टर किसी वास्तविक फाइल, एक डिवाइस (जैसे हार्ड डिस्क), या एक नेटवर्क सॉकेट से मैप होता है।
लिखने के लिए फाइल डिस्क्रिप्टर कैसे खोलें
जब आप sysopen का उपयोग करके एक नया फाइल डिस्क्रिप्टर बनाते हैं, या File.open का उपयोग करके एक फाइल खोलते हैं, तो आपके पास कुछ विकल्प होते हैं।
डिफ़ॉल्ट रूप से कम्युनिकेशन रीड-ओनली है।
आप एक मोड निर्दिष्ट कर सकते हैं:
r(रीड, डिफ़ॉल्ट)w(राइट)w+(रीड और राइट)a(अपेंड)
उदाहरण:
fd = IO.sysopen('/dev/tty1', 'w+')
यह /dev/tty1 को रीड + राइट मोड के साथ खोलता है।
3 स्टैंडर्ड IO स्ट्रीम्स
जब आप एक नया प्रोग्राम खोलते हैं (आपका एडिटर, टर्मिनल, रूबी इंटरप्रेटर, आदि) तो यह डिफ़ॉल्ट रूप से कम्युनिकेशन के 3 चैनल खोलता है।
3 फाइल डिस्क्रिप्टर्स।
वे हैं:
- stdin (इनपुट)
- stdout (आउटपुट)
- stderr (एरर्स)
रूबी में आप इन्हें सीधे एक्सेस कर सकते हैं, उनके कॉन्स्टेंट फॉर्म या उनके ग्लोबल वेरिएबल फॉर्म का उपयोग करके।
उदाहरण:
$stdout << "abc\n"
जब आप $stdout पर लिखते हैं, तो यह puts मेथड को कॉल करने के समान है।
स्टैंडर्ड आउटपुट आपके टर्मिनल से जुड़ा होता है।
lrwx------ 1 jesus jesus 64 Feb 3 15:54 0 -> /dev/pts/3
यह /dev/pts/3 एक वर्चुअल डिवाइस है जिसे आपका टर्मिनल स्क्रीन पर टेक्स्ट प्रदर्शित करने के लिए पढ़ता है।
स्टैंडर्ड एरर भी आउटपुट के लिए उपयोग किया जाता है, लेकिन यह आपके टर्मिनल को इस कंटेंट को अलग तरीके से प्रस्तुत करने का मौका देता है, जैसे बड़े फॉन्ट में, या नियमित टेक्स्ट से अलग रंग में।
आप warn मेथड का उपयोग करके स्टैंडर्ड एरर पर प्रिंट कर सकते हैं।
स्टैंडर्ड इनपुट वह जगह है जहां से उपयोगकर्ता इनपुट पढ़ा जाता है।
आप gets मेथड का उपयोग करके स्टैंडर्ड इनपुट से पढ़ सकते हैं।
STDOUT को फ्लश कैसे करें और बफरिंग अक्षम करें
IO ऑब्जेक्ट्स का एक आंतरिक बफर होता है।
इनपुट डेटा की एक निश्चित मात्रा पढ़े जाने से पहले सेव की जाएगी।
यही कारण है कि कभी-कभी आप puts का उपयोग करते हैं...
लेकिन आप तब तक कुछ नहीं देखते जब तक प्रोग्राम समाप्त नहीं हो जाता, या बफर भर नहीं जाता!
आप बफरिंग को इस तरह अक्षम कर सकते हैं:
$stdout.sync = true
या आप मैन्युअली बफर को फ्लश कर सकते हैं:
$stdout.flush
बफर अक्षम होने के साथ आप आउटपुट को इंतजार किए बिना देखेंगे।
चंक्स में पढ़ना
जब आप IO ऑब्जेक्ट से पढ़ रहे होते हैं, तो आप read करते हैं जब तक स्ट्रीम END-OF-FILE (EOF) सिग्नल के साथ समाप्त नहीं होती, स्ट्रीम बंद हो जाती है, या आप बाइट्स की एक विशिष्ट मात्रा प्राप्त करते हैं।
नेटवर्क प्रोग्रामिंग और बड़ी फाइलों के लिए, छोटे चंक्स में पढ़ना मददगार होता है।
आप चंक्स में इस तरह पढ़ सकते हैं:
data = "" until io.eof? data << io.read(2048) end
इस कोड के साथ आप पूरे डाउनलोड के खत्म होने का इंतजार किए बिना डेटा को प्रोसेस कर सकते हैं जैसे ही यह उपलब्ध होता है।
ध्यान दें कि eof? "ब्लॉक" करेगा।
ब्लॉकिंग का मतलब है कि आपका कोड सो जाएगा जब तक ऑपरेटिंग सिस्टम सिग्नल नहीं देता कि पढ़ने के लिए नया डेटा है।
टू-वे कम्युनिकेशन के लिए IO पाइप्स का उपयोग कैसे करें
रूबी आपको पाइप्स बनाने की अनुमति देता है।
एक पाइप फाइल डिस्क्रिप्टर्स की एक जोड़ी है जो एक दूसरे से जुड़े होते हैं।
इसका उपयोग इंटर-प्रोसेस कम्युनिकेशन (IPC) के लिए किया जाता है।
उदाहरण:
read, write = IO.pipe
आप इसे fork मेथड के साथ उपयोग कर सकते हैं (विंडोज में उपलब्ध नहीं) वर्तमान प्रोसेस की एक कॉपी बनाने के लिए।
ये दो प्रोसेसेस पाइप का उपयोग करके कम्युनिकेट कर सकते हैं।
उदाहरण:
if fork
write.close
puts "Message received: #{read.gets}"
read.close
else
read.close
write << "Buy some bananas!"
write.close
end
जिसके परिणामस्वरूप:
# Message received: Buy some bananas!
कर्नेल ओपन मेथड का उपयोग कैसे करें
रूबी में एक बहुत लचीला open मेथड है।
यह आपको फाइलें खोलने और URL से डेटा पढ़ने की अनुमति देता है, और यहां तक कि एक्सटर्नल कमांड्स चलाने के लिए पाइप्स खोलने की भी।
उदाहरण:
open "abc.txt"
यही कारण है कि इस मेथड से बचा जाना चाहिए।
यह एक सुरक्षा जोखिम है कि यह ये सभी चीजें कर सकता है।
इसके बजाय, उस विशिष्ट open मेथड का उपयोग करना बेहतर है जिसकी आपको आवश्यकता है।
उदाहरण:
File.open # File IO.popen # Process URI.parse(...).open # URL
ये सभी एक IO ऑब्जेक्ट लौटाते हैं।
सारांश
आपने रूबी में इनपुट/आउटपुट के बारे में सीखा! आपने फाइल डिस्क्रिप्टर्स, IO क्लास, बफरिंग, चंक्स में पढ़ना और स्टैंडर्ड IO स्ट्रीम्स के बारे में सीखा।
अगर आपको यह लेख पसंद आया तो इसे शेयर करना न भूलें।
पढ़ने के लिए धन्यवाद।
