வெவ்வேறு கணினி மொழிகள் வெவ்வேறுவகைகளிலான தொடரியலில் இருந்தாலும் குறிப்பிட்டஎந்தவொரு பணியையும் துல்லியமாக செய்கின்றன. ஏனெனில், நிரலாக்க மொழிகள் அனைத்தும் பல ஒற்றுமைகளைக் கொண்டிருக்கின்றன, மேலும் ஒரு நிரலாக்க மொழியை நாம் அறிந்துகொண்டவுடன், அதன் இலக்கணத்தையும் கட்டமைப்பையும் கண்டுபிடித்து அறிந்துகொள்வதன் மூலம் மற்றொரு கணினிமொழியை மிகஎளிதாகக் கற்றுக்கொள்ளலாம். அதே மனப்பான்மையில், வெவ்வேறு நிரலாக்க மொழிகள் தரவுகளை எவ்வாறு படிக்கின்றன, எழுதுகின்றன என்பதை இப்போது காண்போம். அவ்வாறான தரவுகளானவை உள்ளமைவு கோப்பிலிருந்து வந்ததாகஇருந்தாலும் அல்லது பயனாளர் ஒருவர் உருவாக்குகின்ற கோப்பிலிருந்து வந்தாலும், சேமிப்பக சாதனத்தில் அத்தரவுகளைச் செயலாக்கம் செய்வதே நிரலாளர்களின் பொதுவான பணியாகும். இந்த வழியில் அனைத்து நிரலாக்க மொழிகளையும் உள்ளடக்குவது வழக்கமான நடைமுறையில்லை, இருந்தபோதிலும் இந்த கட்டுரையில் இந்த கணினி மொழிகளால் பின்பற்றப்பட்ட வெவ்வேறு அணுகுமுறைகளைப் பற்றிய தெரிந்துகொள்க
C ,C++ ,Java ,Groovy ,Lua ,Bash ,Python ஆகிய கணினி மொழிகளில் தரவுகளைப் படித்தல் , எழுதுதல்
எந்தவொரு கணினியிலும் தரவுகளைப் படிக்கின்ற எழுதுகின்ற செயல்முறையானவை நம்முடைய நடைமுறை வாழ்க்கையில் தரவுகளைப் படிப்பது எழுதுவது போன்றதேயாகும். அதாவது ஒரு புத்தகத்தில்உள்ள தரவுகளை அணுக, முதலில் அந்த புத்தகத்தைத் திறக்கின்றோம், பின்னர் அதிலுள்ள சொற்களைப் படிக்கின்றோம் அல்லது புத்தகத்தில் புதிய சொற்களை எழுதுகின்றோம், பின்னர் புத்தகத்தை மூடுகின்றோம் அல்லவா.அதேபோன்று நம்முடைய நிரலாக்கமானது ஒரு கோப்பிலிருந்து தரவைப் படிக்க வேண்டியிருக்கும் போது, நிரலாக்கத்திடம் அந்த கோப்பு இருக்கின்ற இருப்பிடத்தினை குறிப்பிடுகின்றோம், பின்னர் கணினி அந்த கோப்பிலிருந்து தரவுகளை அதன் தற்காலிக நினைவகத்திற்கு (RAM) கொண்டு வந்து பாகுபடுத்தி படிக்கச்செய்கின்றது. இதேபோல், நம்முடைய நிரலாக்கமானது ஒரு கோப்பிற்குள் தரவுகளை எழுத வேண்டியிருக்கும் போது, அவ்வாறான புதிய தரவை கணினியின் நினைவக இடையகத்தில் எழுதி சேமிப்பக சாதனத்தில் உள்ள கோப்பில் ஒத்திசைவுசெய்து எழுதுகிறது அதற்கான படிமுறை பின்வருமாறு.
1. முதலில் நினைவகத்தில் ஒரு கோப்பை ஏற்றிடுக.
2. பின்னர் கோப்பின் உள்ளடக்கங்களைப் படித்திடுக அல்லது கோப்பில் தரவை எழுதிடுக.
3. இறுதியில் கோப்பை மூடிடுக.
ஒரு கோப்பிலிருந்து தரவைப் படித்தல்
. C எனும் கணினி மொழி
சி எனும் கணினி மொழியில், ஒரு கோப்பைத் திறப்பது என்பது நம்முடைய தேவைகளையும் அணுகுமுறையையும் பொறுத்து ஒற்றை எழுத்தை ( EOF வடிவமைப்பாளர், சைகையாளர் கோப்பின் முடிவு வரைக் குறிக்கிறது) அல்லது தரவுகளின் தொகுப்பை மீட்டெடுப்பதை உள்ளடக்கியது. இது நம்முடைய இலக்கைப் பொறுத்து பெரும்பாலும் கைகாளால் செய்யப்படுகின்ற செயல்முறைபோன்று உணர முடியும், ஆனால் பொதுவான செயல்முறை மற்ற கணினிமொழிகளிலும் அவ்வாறே இருக்கின்றன
FILE *infile;
int ch;
infile = fopen(argv[1], “r”);
do {
ch = fgetc(infile);
if (ch != EOF) {
printf(“%c”, ch);
}
} while (ch != EOF);
fclose(infile);
ஒரு கோப்பின் சில பகுதியை கணினி இடையகத்தில் ஏற்றிடுக, பின்னர் இடையகத்திலிருந்து வெளியேறிடுமாறு தேர்வு செய்திடுக.
FILE *infile;
char buffer[300];
infile = fopen(argv[1], “r”);
while (!feof(infile)) {
size_t buffer_length;
buffer_length = fread(buffer, sizeof(char), 300, infile);
}
printf(“%s”, buffer);
fclose(infile);
C++எனும் கணினி மொழி
சி ++ எனும் கணினி மொழியில் சில படிமுறைகளை எளிதாக்குகிறது, இது தரவுகளை சரங்களாக ஆய்வுசெய்திட அனுமதிக்கிறது.
std::string sFilename = “example.txt”;
std::ifstream fileSource(sFilename);
std::string buffer;
while (fileSource >> buffer) {
std::cout << buffer << std::endl;
}
Java எனும் கணினி மொழி
Java ,Groovy ஆகிய கணினி மொழிகள் சி ++ எனும் கணினி மொழியை ஒத்தவைகளாகும். நாம் விரும்பும் கோப்பின் உள்ளடக்கங்களைக் கொண்ட தரவுகளின் பொருட்கள் அல்லது தாரையோட்டத்தினை அமைக்க Scanner எனும் இனத்தினைப் பயன்படுத்துகின்றன. இருமஎண், வரி, முழு எண் , போன்ற பல அனுமதிகளின் மூலம் கோப்பு வழியாக ” Scan” செய்ய முடியும்.
File myFile = new File(“example.txt”);
Scanner myScanner = new Scanner(myFile);
while (myScanner.hasNextLine()) {
String line = myScanner.nextLine();
System.out.println(line);
}
myScanner.close();
Groovy
def myFile = new File(‘example.txt’)
def myScanner = new Scanner(myFile)
while (myScanner.hasNextLine()) {
def line = myScanner.nextLine()
println(line)
}
myScanner.close()
Lua எனும் கணினிமொழி
Lua , Python ஆகிய கணினி மொழிகளில் இந்த செயல்முறையை மேலும் சுருக்கமாக செய்யப்படுகின்றது. நாம் ஒரு தரவு தாரையோட்டத்தினை (stream) உணர்வுபூர்வமாக உருவாக்க வேண்டியதில்லை; திறந்த செயலியின் முடிவுகளுக்கு ஒரு மாறியை ஒதுக்கீடு செய்திடுக, பின்னர் மாறியின் உள்ளடக்கங்களை இது பகுத்திடுகின்றது.ஆயினும் இது விரைவாக செயல்படக்கூடியது, குறைவான நினைவகமே போதுமானது, எளிதாக செயல்படுத்தக்கூடியது
myFile = io.open(‘example.txt’, ‘r’)
lines = myFile:read(“*all”)
print(lines)
myFile:close()
Python
f = open(‘example.tmp’, ‘r’)
for line in f:
print(line)
f.close()
ஒரு கோப்பில் தரவை எழுதுதல்
குறிமுறைவரிகளைப் பொறுத்தவரை, கோப்பில் தரவுகளை எழுதுவது என்பது படித்திடும் செயலிற்கான தலைகீழ்(எதிர்மறை)செயலாகும். எனவே, ஒரு கோப்பிற்கு தரவுகளை எழுதுவதற்கான செயல்முறை அடிப்படையில் ஒரு கோப்பிலிருந்து தரவைப் படிப்பதைப் போன்றது, வெவ்வேறு செயலிகளைப் பயன்படுத்துவதைத் தவிர வேறொன்றும் புதிய செயல்எதுவும் இல்லை.
Cஎனும் கணினிமொழி
Cஎனும் கணினிமொழியில், நாம் fputc எனும் செயலியுடன் ஒரு கோப்பில்ஒரு எழுத்தை எழுதலாம்
fputc(ch, outfile);
மாற்றாக, நாம் fwrite உடன் இடையகத்திற்கு தரவை எழுதலாம்.
fwrite(buffer, sizeof(char), buffer_length, outfile);
C++எனும் கணினிமொழி
தரவுகளுக்கான இடையகநினைவகத்தைத் திறக்க சி ++எனும் கணினிமொழியில் ifstream நூலகத்தைப் பயன்படுத்துவதால், சி ++ இன் நூலகங்களைத் தவிர சி எனும் கணினிமொழி போலவே தரவுகளை இடையகநினைவகத்தில் எழுதலாம்.
std::cout << buffer << std::endl;
Javaஎனும் கணினிமொழி
ஜாவாஎனும் கணினிமொழியில், தரவை எழுதக்கூடிய தரவுகளின் பொருளை உருவாக்க FileWriter எனும்இனத்தினைப் பயன்படுத்தலாம். இது வேறு வழியில் செயல்படுவதைத் தவிர Scanner எனும் இனத்தினைப் போலவே ஏராளமான பணியை செய்கிறது,.
FileWriter myFileWriter = new FileWriter(“example.txt”, true);
myFileWriter.write(“Hello world\n”);
myFileWriter.close();
Groovy எனும் கணினிமொழி
மேலே கூறியதைபோன்றே, Groovy எனும் கணினிமொழியில் FileWriter எனும் செயலி சற்று வித்தியாசமாக “groovier” எனும் தொடரியல் மூலம் பயன்படுத்தி கொள்கின்றது,
new FileWriter(“example.txt”, true).with {
write(“Hello world\n”)
flush()
}
Lua எனும் கணினிமொழி
Lua Pythonஆகிய இரண்டும் ஒத்தவைகளாகும், இவை இரண்டும் ஒரு கோப்பை நினைவகத்தில் ஏற்றுவதற்கு open என அழைக்கப்படும் செயலிகளைப் பயன்படுத்துகின்றன, பின்னர் தரவுகளை அதில் வைத்து எழுதுகின்றன, மேலும் கோப்பை மூட closeஎனும் செயலியை பயன்படுத்தி கொள்கின்றன.
Lua எனும் கணினிமொழி
myFile = io.open(‘example.txt’, ‘a’)
io.output(myFile)
io.write(“hello world\n”)
io.close(myFile)
Python எனும் கணினிமொழி
myFile = open(‘example.txt’, ‘w’)
myFile.write(‘hello world’)
myFile.close()
கோப்புகளை பயன்படுத்தி கொள்ளும் வழிமுறைகள்
கோப்புகளைத் திறக்கும்போது பல கணினிமொழிகள்பின்வருகின்ற “mode” குறியீடுகளை குறிப்பிடுகின்றன. இதற்கான வழிமுறைகள் மாறுபடும், ஆனால் இவை பொதுவான குறியீடுகளாகும் அவை :
எழுத w என்பதும், படிக்க r என்பதும் , படிக்கவும் எழுதவும் r + என்பதும், சேர்க்க மட்டும் Append என்பதும் பொதுவான குறியீடுகளாகும்
Java , Groovy போன்ற சில கணினி மொழிகள், கோப்பை ஏற்ற எந்தவொரு இனத்தின் பயன்முறை(mode) அடிப்படையிலும் நம்மை தீர்மானிக்க அனுமதிக்கின்றன. நிரலாக்க மொழி எந்த வொரு வழியிலும் ஒரு கோப்பின் பயன்முறையை தீர்மானிக்கிறது, புதிய தரவுகளோடு ஒரு கோப்பை மேலெழுத விரும்பவில்லை எனில், தரவுகளைச் சேர்ப்பதை உறுதிசெய்வது நம்முடைய பணியாகும். நிரலாக்க மொழிகளில் உள்ளமைக்கப்பட்ட தரவு இழப்புக்கு எதிராக நம்மைத் எச்சரித்து நாம் செயல்படுமாறு தூண்டுகிறது, இதுவே கோப்பு தேர்வாளர்கள் செய்யும் வழிமுறையாகும்.
புதிய மொழி , பழைய தந்திரங்கள்
ஒவ்வொரு நிரலாக்க மொழியும் ஒவ்வொரு பணியையும் நிறைவேற்றுவதற்காக தத்தமெக்கென தனித்துவமான வழியைக் கொண்டுள்ளன; அதனால்தான் நாம் தேர்வு செய்வதற்காகவென பல கணினிமொழிகள் உள்ளன. அவைகளுள் நமக்கு ஏற்ற கணினி மொழி ஒன்றினை நாம் தேர்வு செய்யலாம். ஆனால் நிரலாக்கத்தின் அடிப்படைக் கட்டமைப்பை நாம் புரிந்துகொண்டவுடன், அடிப்படை பணிகளை எவ்வாறு நிறைவேற்றுவது என்று தெரியாமல், வெவ்வேறு கணினி மொழிகளையும் முயற்சிக்க தயங்கலாம். பெரும்பாலும், குறிக்கோளின் பாதைகள் ஒத்தவை, எனவே நாம் அடிப்படைக் கருத்துக்களை மனதில் கொண்டிருக்கும் வரை அவற்றை கற்றுக்கொள்வது எளிதானதாகும்.