எளிய, இனிய கணினி மொழி – ரூபி – 24 – கோப்புகளைக் கையாளுதல்

முந்தைய அத்தியாயத்தில் கோப்பகங்களை எப்படி கையாளுவதெனப்பார்த்தோம். இந்த அத்தியாயத்தில் ரூபியில் கோப்புகளை எப்படி உருவாக்குவது, எப்படி திறப்பது, படிப்பது மற்றும் எழுதுவது எப்படியென்று பார்ப்போம். மேலும் கோப்புகளை எவ்வாறு அழிப்பது மற்றும் பெயர் மாற்றுவதென்றும் காண்போம்.

புதிய கோப்பை உருவாக்குதல்:

ரூபியில் ஒரு புது கோப்பை உருவாக்க file வர்க்கத்திலுள்ள new செயற்கூற்றைப் பயன்படுத்தலாம். New செயற்கூற்றிற்கு இரண்டு arguments கொடுக்க வேண்டும். ஒன்று உருவாக்க வேண்டிய கோப்பின் பெயர், மற்றொன்று எந்த முறையில் கோப்பை திறக்க வேண்டும் என்று கொடுக்க வேண்டும். கோப்ப்பைத்திறக்கும் முறைகளை பின்வரும் அட்டவணையில் காணலாம்:

Mode

விளக்கம்

r

படிக்க மட்டும் அனுமதி. குறியீட்டு புள்ளியானது கோப்பின் தொடக்கத்தில் இருக்கும்.

r+

படிக்க மற்றும் எழுத அனுமதி. குறியீட்டு புள்ளியானது கோப்பின் தொடக்கத்தில் இருக்கும்.

w

எழுத மட்டும் அனுமதி. குறியீட்டு புள்ளியானது கோப்பின் தொடக்கத்தில் இருக்கும்.

w+

படிக்க மற்றும் எழுத அனுமதி. குறியீட்டு புள்ளியானது கோப்பின் தொடக்கத்தில் இருக்கும்.

a

எழுத மட்டும் அனுமதி. குறியீட்டு புள்ளியானது கோப்பின் முடிவில் இருக்கும்.

a+

படிக்க மற்றும் எழுத அனுமதி. குறியீட்டு புள்ளியானது கோப்பின் முடிவில் இருக்கும்.

b

Binary File Mode.மேலே உள்ள செய்முறைகளோடு இணைந்து பயன்படும். Windows/DOS மட்டும்.

பின்வரும் எடுத்துக்காட்டில், ஒரு புது கோப்பை எழுதுவதற்கான முறையில் (write mode) உருவாக்குவதை காணலாம்:

File.new("temp.txt", "w")
=> #<File:temp.txt>

ஏற்கனவே உள்ள கோப்பைத் திறத்தல்:

File வர்க்கத்திலுள்ள open செயற்கூற்றைக் கொண்டு ஏற்கனவே உள்ள கோப்பை திறக்கலாம்:

file = File.open("temp.txt")
=> #<File:temp.txt>

ஏற்கனவே உள்ள கோப்பை திறக்க மேலே உள்ள அட்டவணைப்படி பல செய்முறைகள் உள்ளன. பின்வரும் எடுத்துக்காட்டில், நாம் கோப்பை படிப்பதற்காக (read mode) மட்டும் திறக்க செய்வதை காணலாம்,

file = File.open("temp.txt", "r")
=> #<File:temp.txt>

மேலும், கோப்பு ஏற்கனவே திறந்திருக்கிறதா என்பதை closed? என்ற செயற்கூற்றைக் கொண்டு அறியலாம்:

file.closed?
=> false

முடிவாக, close செயற்கூற்றைக் கொண்டு கோப்பை மூடிவிடமுடியும்:

file = File.open("temp.txt", "r")
=> #<File:temp.txt>
file.close
=> nil

கோப்பின் பெயரை மாற்றுதல் மற்றும் நீக்குதல்:

ரூபியில் கோப்பை பெயர்மாற்றம் செய்யவும், நீக்கவும் rename மற்றும் delete செயற்கூறுகளை பயன்படுத்தவேண்டும். பின்வரும் உதாரணத்திற்கு ஒரு புதிய கோப்பை உருவாக்கி, பெயர்மாற்றம் செய்து பின்னர், நீக்குவதைக்காணலாம்:

File.new("tempfile.txt", "w")
=> #<File:temp.txt>

File.rename("tempfile.txt", "newfile.txt")
=> 0

File.delete("newfile.txt")
=> 1

கோப்புகள் பற்றிய விவரங்களை பெறுதல்:

சில நேரங்களில் கோப்பைத்திறப்பதற்கு முன்னதாக அதன் விவரங்களைப்பெறுவது அவசியமாகும். இந்த தேவைக்கேற்ப பல செயற்கூறுகளை File வர்க்கத்தில் காணலாம்:

கொடுக்கப்பட்ட பெயரில் ஒரு கோப்பு இருக்கிறதா என அறிய, exists செயற்கூற்றைப்பயன்படுத்தலாம்.

File.exists?("temp.txt")
=> true

கொடுக்கப்பட்ட பாதையில் உள்ளது ஒரு கோப்புதானா (அல்லது கோப்பகமா) என்பதை, file? செயற்கூறு கொண்டு அறியலாம்.

File.file?("ruby")
=> false

அதேப்போல், கோப்பகத்தை அறிய directory? செயற்கூற்றைக் கொண்டு கண்டுப்பிடிக்கலாம்:

File.directory?("test")
=> true

ஒரு கோப்பை படிக்கமுடியுமா, அதில் எழுதமுடியுமா, அதை செயல்படுத்த முடியுமா என்பதை readable?, writable? மற்றும் executable? செயற்கூறுகள் கொண்டு அறியலாம்:

File.readable?("temp.txt")
=> true

File.writable?("temp.txt")
=> true

File.executable?("temp.txt")
=> false

ஒரு கோப்பின் அளவை அறிய size செயற்கூற்றைப் பயன்படுத்தலாம்:

File.size("temp.txt")
=> 174

மேலும், கோப்பு காலியாக உள்ளதா என்பதை zero? செயற்கூறு கொண்டு அறியலாம்:

File.zero?("temp.txt")
=> false

Ftype செயற்கூற்றைக் கொண்டு கோப்பின் வகையை கண்டுப்பிடிக்கலாம்:

File.ftype("temp.txt")
=> "file"

File.ftype("../ruby")
=> "directory"

இறுதியாக, கோப்பினை உருவாக்கிய,மாற்றிய மற்றும் பயன்படுத்திய நேரத்தை கண்டுப்பிடிக்க ctime, mtime மற்றும் atime செயற்கூறுகளைக் கொண்டு கண்டுப்பிடிக்கலாம்:

File.ctime("temp.txt")

File.mtime("temp.txt")

File.atime("temp.txt")

கோப்பில் எழுத மற்றும் வாசிக்க:

ஒருமுறை, ஏற்கனவே உள்ள கோப்பையோ அல்லது ஒரு புது கோப்பையோ திறந்தால், அதில் நாம் எழுதலாம் மற்றும் படிக்கலாம். நாம் கோப்பைப்படிக்க ஒன்று readline செயற்கூற்றைப் பயன்படுத்தலாம்:

myfile = File.open("temp.txt")
=> #<File:temp.txt>

myfile.readline
=> "This is a test file\n"

myfile.readline
=> "It contains some example lines\n"

மாற்றாக, நாம் each செயற்கூற்றைப் பயன்படுத்தி முழு கோப்பையும் படிக்கலாம்:

myfile = File.open("temp.txt")
=> #<File:temp.txt>

myfile.each {|line| print line }
This is a test file
It contains some example lines
But other than that
It serves no real purpose

நாம் getc செயற்கூற்றைப் பயன்படுத்தி ஒரு கோப்பில் ஒவ்வொரு எழுத்தாக பெற முடியும்:

myfile = File.open("Hello.txt")
=> #<File:Hello.txt>

myfile.getc.chr
=> "H"
myfile.getc.chr
=> "e"
myfile.getc.chr
=> "l"

Putc செயற்கூற்றைப் பயன்படுத்தி ஒரு நேரத்தில் ஒரு எழுத்தை எழுத முடியும் மற்றும் வார்த்தை, வாக்கியங்களை எழுத puts செயற்கூற்றைப் பயன்படுத்தலாம். ஆனால் இதில் கவனிக்க வேண்டியது என்னவென்றால் எழுதிய பின் rewind செயற்கூற்றை அழைக்க வேண்டும். இது குறியீட்டு புள்ளியை கோப்பின் ஆரம்பத்திற்கு திருப்பி அனுப்பும் அதனால் நாம் எழுதியதை படிக்க இயலும்.

myfile = File.new("write.txt", "w+")
=> #<File:write.txt>

myfile.puts("This test line 1")
=> nil

myfile.puts("This test line 2")
=> nil

myfile.rewind
=> 0

myfile.readline
=> "This test line 1\n"

myfile.readline
=> "This test line 2\n"

— பிரியா – priya.budsp@gmail.com – ஐக்கிய அரபு அமீரகம்

%d bloggers like this: