रूबी - फ़ाइल I / O

रूबी कर्नेल मॉड्यूल में कार्यान्वित 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 )
अनु क्रमांक। मुखौटा और विवरण
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 क्लास और तरीके ।