रूबी में इनपुट और आउटपुट (आईओ):निश्चित गाइड

I/O का मतलब इनपुट/आउटपुट है।

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

इनपुट के उदाहरण :

• कीबोर्ड पर आपके प्रेस की कुंजी
• माउस क्लिक
• आपके द्वारा पढ़ी जाने वाली पुस्तकें

आउटपुट से हमारा मतलब वह सब कुछ है जो इनपुट के परिणामस्वरूप निकलता है।

आउटपुट के उदाहरण :

• 1 + 1 का परिणाम
• आपके द्वारा पढ़े गए लेख का सारांश लिखना
• कॉफ़ी

रूबी में, जब हम i/o के बारे में बात करते हैं तो हम आमतौर पर फाइलों को पढ़ने, नेटवर्क सॉकेट के साथ काम करने और स्क्रीन पर प्रिंटिंग जानकारी का उल्लेख करते हैं।

आईओ क्लास को समझना

रूबी में IO भी एक वर्ग है।

यह अन्य वस्तुओं जैसे File . के लिए मूल वर्ग है &Socket ।

सभी IO ऑब्जेक्ट्स में ये ऑपरेशन होते हैं :

• खोलें / बंद करें
• पढ़ें
• लिखें

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 opens खोलता है रीड + राइट मोड के साथ।

3 मानक IO स्ट्रीम

जब आप एक नया प्रोग्राम खोलते हैं (आपका संपादक, टर्मिनल, रूबी दुभाषिया, आदि) तो यह डिफ़ॉल्ट रूप से संचार के 3 चैनल खोलता है।

3 फाइल डिस्क्रिप्टर।

वे हैं :

• स्टडिन (इनपुट)
• स्टडआउट (आउटपुट)
• stderr (त्रुटियां)

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

उदाहरण :

$stdout << "abc\n"

जब आप $stdout . को लिखते हैं , यह पुट मेथड को कॉल करने जैसा ही है।

मानक आउटपुट आपके टर्मिनल से जुड़ा है।

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 पाइप्स का उपयोग कैसे करें

रूबी आपको पाइप बनाने की अनुमति देती है।

एक पाइप फाइल डिस्क्रिप्टर की एक जोड़ी है जो एक दूसरे से जुड़े होते हैं।

इसका उपयोग इंटर-प्रोसेस कम्युनिकेशन (आईपीसी) के लिए किया जाता है।

उदाहरण :

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 open
URI.parse(...).open # URL open

ये सभी एक IO लौटाते हैं वस्तु।

सारांश

आपने रूबी में इनपुट/आउटपुट के बारे में सीखा है! आपने फाइल डिस्क्रिप्टर के बारे में सीखा है, IO वर्ग, बफरिंग, भागों में पढ़ना और मानक IO धाराएँ।

अगर आपको यह लेख पसंद आए तो इसे शेयर करना न भूलें।

पढ़ने के लिए धन्यवाद।