கோ எனும் கணினிமொழியில் கோப்புகளை நகலெடுத்திடும் வழிமுறை

கோ எனும் கணினிமொழியில் கோப்புகளை நகலெடுத்து கொண்டுவந்து சேர்த்திடுவதற்காக பல்வேறு வழிமுறைகள் உள்ளன அவற்றுள் இந்த கோஎனும் கணினிமொழியின் துவக்கப்பதிப்புகளின் நூலகத்தில் உள்ள செயலியான io.Copy()என்பதை கொண்டு செயல்படுத்திடலாம் இது முதலில்உள்ளீடு செய்திடும் கோப்பினை உடனடியாக படித்தறிந்து கொண்டு அதனடிப்படையில் வேறொருகோப்பினை எழுதுகின்றது இவ்வாறு கோப்பினை நகலெடுத்து பிரிதொரு கோப்பாக எழுதி உருவாக்குவதற்கான cp1.goஎனும் குறிமுறைவரிகள் பின்வருமாறு
func copy(src, dst string) (int64, error) {
sourceFileStat, err := os.Stat(src)
if err != nil {
return 0, err
}
if !sourceFileStat.Mode().IsRegular() {
return 0, fmt.Errorf(“%s is not a regular file”, src)
}
source, err := os.Open(src)
if err != nil {
return 0, err
}
defer source.Close()
destination, err := os.Create(dst)
if err != nil {
return 0, err
}
defer destination.Close()
nBytes, err := io.Copy(destination, source)
return nBytes, err
}
இதனைபரிசோதித்து பார்த்திடும்போதுos.Stat(src) எனும் நடப்பு கோப்பானது நகலெடுக்கப்பட்டு sourceFileStat.Mode().IsRegular() எனும் வழக்கமான கோப்பாக செய்யப்படுகின்றது தேவையெனில் இதனை திறந்து படித்து சரிபார்த்து கொள்ளமுடியும் இதில் நகலெடுத்து கொண்டுவந்து சேர்த்திடும்அனைத்து செயல்களும் io.Copy(destination, source)எனும் கட்டளைவரியில் செயல்படுத்தப்படுகின்றது இந்த பணி-முடிவடையும் போது இதுவரை எத்தனை பைட்கள் நகலெடுக்கப்பட்டன அவ்வாறான செயலின்போது ஏற்பட்ட பிழைகள்யாவை எனும்பிழைச்செய்தி பொதுவாக திரையில் காண்பிக்கும்ஆனால் கோஎனும் மொழியில் இவ்வாறான பிழைமதிப்பானது nilஎன்றே காண்பிக்கும்இந்த குறிமுறைவரிகளை செயல்படுத்தினால் அதனுடைய வெளியீடு பின்வருமாறு இருக்கும்
$ go run cp1.go தொடர்ந்து பின்வருமாறான இருகட்டளைவரிகளை செயல்படுத்திடுக
$ go run cp1.go fileCP.txt /tmp/fileCPCOPY , $ diff fileCP.txt /tmp/fileCPCOPY
அதனைதொடர்ந்து அதன் வெளியீடு பின்வருமாறு இருக்கும்
Copied 3826 bytes!
இந்த io.Copy எனும் செயலி பற்றி மேலும் விவரங்களுக்கு https://golang.org/pkg/io/என்ற இணையபக்கத்திற்கு சென்றறிந்து கொள்க

பைத்தான் எனும் கணினிமொழியில் உருவாக்கப்படும் குறிமுறைவரிகளில் எழும் பிரச்சினைகளுக்கு நேர்த்தியான தீர்வைகாணலாம்

ஒருசில வழிமுறைகளை கொண்டு பைத்தான் எனும் கணினிமொழியில் உருவாக்கப்படும் குறிமுறைவரிகளில் எழும் பிரச்சினைகளுக்கு நேர்த்தியான தீர்வைகண்டு மேலும் மேம்படுத்தி கொள்ளமுடியும்
பைத்தான் எனும் கணினிமொழியில் குறிமுறைவரிகளை உருவாக்கிடும்போது இந்த வழிமுறைகளை கொண்டு அக்குறிமுறைவரிகளை மிகமேம்பட்டதாக உயர்த்திகொள்ளமுடியும் எடுத்துகாட்டு குறிமுறைவரிகள் பின்வருமாறு
classMoney:
currency_rates={
‘$’:1,
‘€’:0.88,
}
def__init__(self,symbol,amount):
self.symbol=symbol
self.amount=amount
def__repr__(self):
return’%s%.2f’%(self.symbol,self.amount)
defconvert(self,other):
“”” Convert other amount to our currency “””
new_amount=(
other.amount/self.currency_rates[other.symbol]
*self.currency_rates[self.symbol])
returnMoney(self.symbol,new_amount)
இந்த குறிமுறை வரிகளில் _init__()எனும் வழிமுறையின் வாயிலாக பணத்தினை அதற்கான குறியீட்டின் வாயிலாகவும் பரிமாற்றவிகிதத்தின் வாயிலாகவும் வரையறுத்திடுகின்றோம் தொடர்ந்து _repr__எனும்வழிமுறையின் வாயிலாக அதனை செயல்படுத்திடுகின்றோம். அதனை தொடர்ந்து இதனை அச்சிடமுயலும்போதுMoney எனும் இனத்துடன் Money(‘$’, 2.00) என்றவாறு பணத்திற்கான குறியீட்டுடன் தொகையும் அச்சிடுகின்றது இந்தவழிமுறையானது வெவ்வேறு பணத்திற்கானகுறியீடுகளையும் வெவ்வேறு பணபரிமாற்ற விகிதங்களையும் எளிதாக கையாளுகின்றது என்ற தகவலை மனதில்கொள்க அவ்வாறே வெவ்வேறு உணவுப்-பொருட்களுக்கான பணத்தின் குறியீடுகளையும் அதற்கன பணபரிமாற்ற விகிதங்களையும் இந்த வழிமுறையானது எளிதாக கையாளுகின்றது
>>>soda_cost=Money(‘$’,5.25)
>>>soda_cost
$5.25
>>>pizza_cost=Money(‘€’,7.99)
>>>pizza_cost
€7.99
மேலும்__add__எனும் வழிமுறை நம்முடையMoney எனும் இனத்துடன் இடைமுகம் செய்கின்றது
classMoney:
# … previously defined methods …
def__add__(self,other):
“”” Add 2 Money instances using ‘+’ “””
new_amount=self.amount+self.convert(other).amount
returnMoney(self.symbol,new_amount)
அதுமட்டுமல்லாது இருதொகைகளின்கூடுதலை பின்வருமாறு காணமுடியும்
>>>soda_cost=Money(‘$’,5.25)
>>>pizza_cost=Money(‘€’,7.99)
>>>soda_cost + pizza_cost
$14.33
>>>pizza_cost + soda_cost
€12.61
என்றவாறு புதியதாக தொகைக்கான கூடுதல் அந்தந்த குறியீடுகளின் அடிப்படையில் காணமுடியும் இங்கு __add__எனும் வழிமுறைக்கு பதிலாக +எனும்கூடுதல் குறியீடு அதே பணியை சிறப்பாக செய்கின்றது
இரு தொகைகளை கழித்துவிடை காண __sub__ எனும் வழிமுறையும் பெருக்கிவிடை காண __mul__எனும் வழிமுறையும் உதவுகின்றன
பட்டியலில் குறிப்பிட்டதை காண __getitem__எனும் வழிமுறை பயன்படுகின்றது உதாரணமாக
>>>d={‘one’:1,’two’:2}
>>>d[‘two’]
2
>>>d.__getitem__(‘two’)
2
அதேபோன்று__len__()எனும் வழிமுறையானது
classAlphabet:
letters=’ABCDEFGHIJKLMNOPQRSTUVWXYZ’
def__len__(self):
returnlen(self.letters)
>>>my_alphabet=Alphabet()
>>>len(my_alphabet)
26
என்றவாறு காண உதவுகின்றதுஇவ்வாறு பைத்தான் எனும் கணினிமொழியில் முன்கூட்டியே கட்டமைக்கப்பட்டுள்ள ஒரு சில வழிமுறைகளை கொண்டு நம்முடைய குறிமுறைவரிகளில் எழும் பிரச்சினைகளுக்கு நேர்த்தியான தீர்வைகண்டுமேம்படுத்தி கொள்க

ஜாவா10 எனும் கணினிமொழி ஒருஅறிமுகம்

ஜாவா9 வெளியிடப்பட்டு ஏறத்தாழ ஆறுமாதத்தில் ஜாவா10 பதிப்பை தற்போது ஆரக்கிள் நிறுவனம் வெளியிட்டுள்ளது இது JavaSE10எனும்தளத்தில் செயல்படுமாறு JSR383கோரியவாறு கட்டற்ற JDKகுழுவால் JEP2ஆல் தேடிபிடித்திடுமாறு வெளியிடப்பட்டுள்ளது இதனுடைய பல்வேறு சிறப்பம்சங்கள் பின்வருமாறு
1.உள்ளூர் மாறிலிகள் வகை இடைமுகம்
List list = new ArrayList();
என்பதற்கு பதிலாக
var list = new Array(); //infers ArrayList
என்றவாறுvar எனும் திறவுச்சொற்களை கொண்டு உள்ளூர் மாறிலிகளை கொண்டு அறிவித்திடவும் துவக்கநலைமதிப்பாக்கவும் செய்கின்றது
2. G1என்பதற்கு இணையாக Garbage Collector (GC)fullஎனும் இடைமுக இணையான கட்டளைகளினால் செயல்களைவிரைவாக செயல்படசெய்கின்றது
3. Class-data பகிர்ந்துகொள்ளுதல்எனும் பயன்பாட்டினால் metadataவை வெவ்வறு ஜாவா செயல்களுக்கிடையே பகிர்ந்து கொண்டு நடப்பு Class-data பகிர்ந்துகொள்ளுதலை விரிவாக்கம் செய்து இனங்களின் பயன்பாட்டினை அனுமதித்து இதனுடைய துவக்க நேரத்தினை குறைத்திடுகின்றது
4. ஜாவா குறிமுறைவரிகளை இயந்திரமொழிமாற்றம் செய்வதற்காக தனியாக கருவிகளை தன்னகத்தே கொண்டுள்ளது
5. மேலும் இயந்தரமொழிமாற்றம்செய்வதற்காகபுதிய Just In Time(JIT)என்ற வசதி அறிமுகபடுத்தப்படடுள்ளது
6. கூடுதலாக ஒருங்குகுறியீட்டு டேக் விரிவாக்கத்துடன் அனைத்து மொழிகளையும் இணக்கமாக செயல்படுமாறு இது வடிவமைக்கப்பட்டுள்ளது
வருகள. இந்த புதிய ஜாவா 10எனும் பதிப்பாக வெளியிடபட்டுள்ள கணினிமொழியை இன்றே பயன்படுத்திகொள்க

எளிதாககற்கலாம் Rustஎனும் கணினிஅமைவுநிரல்தொடர்மொழியை

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

பல்வேறு தளங்களிலும்இயங்கிடும் திறன்கொண்ட பயன்பாடுகளை உருவாக்குவதற்காக பயன்படும் Kotlinஎனும்கணினிமொழி

தற்போதையநிலையில் உருவாக்கப்படும்எந்தவொரு பயன்பாடும்லினக்ஸ் விண்டோ ,லினக்ஸ்,மட்டுமல்லாது ,ஆண்ட்ராய்டு, ஐஓஎஸ் போன்ற கைபேசியிலும் செயல்படும்திறன்மிக்கதாக இருக்கவேண்டும் என்ற சூழலில்ஜாவா ஸ்கேலா போன்று புதியதாக கோட்லின் என்ற கணினிமொழி அறிமுகபடுத்தப்பட்டுள்ளது இதில் உருவாக்கப்படும் பயன்பாடுகளானது எந்தவொரு இணையஉலாவியின் வாயிலாகும் ஆண்ட்ராய்டு சூழலிலும் ஜாவாமெய்நிகர் கணினிசூழலிலும் செயல்படும் திறன்மிக்கது இதனைகொண்டு தமக்குதேவையான செயலை செயல்படுத்திடுவதை மட்டும் கருத்தில் கொண்டு நிரல்தொடரலாளர்கள் செயல்பட்டால்போதும் அந்த பயன்பாட்டிற்கான அடிப்படை கட்டமைவை இந்த கோட்லின் தானாகவே உருவாக்கிகொள்கின்றது
இதிலுள்ள null pointer exceptionஎனும் வசதியானது பயன்பாட்டினை உருவாக்கிடும்போது ஏற்படும் பல்வேறான பேரளவு பிழைகளை தவிர்த்திடுகின்றது இதன் நூலகத்தை கொண்டு ஜாவா ஆண்ட்ராய்டு போன்ற எந்தவொரு சூழலிலும்செயல்படும் தன்மையுடன் பயன்பாட்டினை மேம்படுத்திடுகின்றது மிகப்பிரபலமான IDEசூழலிலும் செயல்படும் பயனாளரின் இனியநண்பனாக விளங்குகின்றது இதனைhttps://try.kotlinlang.org/ எனும்தளத்திற்கு சென்று நம்முடைய வழக்கமான முதல் நிரல் தொடரான
fun main(args:Arrays){
Println(“அனைவருக்கும் வணக்கம்! “ )
}

என்றவாறு குறிமுறைவரிகளை உருவாக்கி கொண்டு JVM,JavaScript,Junit ஆகியவற்றில் எந்த சூழலில்செயல்படவேண்டும்என தெரிவுசெய்து கொள்க பின்னர் Run எனும் உருவப்-பொத்தானை தெரிவுசெய்து சொடுக்குக outputஎனும் வெளியீட்டு சாளரத்தில் தோன்றிடும்
இதையேகட்டளைவரியில் செயல்படுமாறு செய்திட
fun main(args:Arrays){
if (args.size==0) {
Pintln(“Please provide a name as a command-line argument”)
return
}
Println(“அனைவருக்கும் வணக்கம்! “ )
}

என்றவாறும் திரும்பதிரும்பசெய்திடும் செயலிற்காக
fun main(args:Arrays){
for(name in args)
Println(“அனைவருக்கும் வணக்கம்! “ )
}

என்றவாறும் பொருள்நோக்கு பதிப்பாக
class Greeter(valname: String) {
fun greet(){
Println(“அனைவருக்கும் வணக்கம்!, ${name} “ )

}

}
fun main(args:Arrays){
Greeter(args [0]).greet()
}
என்றவாறும் உருவாக்கலாம் மேலும் விவரங்களுக்க https://kotlinlang.org/ என்ற முவரிக்கு சென்ற ஐயம்திரிபற கற்று பயன்பெறுக என பரிந்துரைக்கப்படுகின்றது

போனி எனும் கணினிமொழி ஒரு அறிமுகம்

மிக விரைவாகவும், பாதுகாப்பானதாகவும், திறனுடையதாகவும் ஆன மிகச் சிறந்த நிரல்தொடர்களை எளிதாக உருவாக்க உதவுவதே போனி எனும் கணினிமொழியாகும்
தற்போதுள்ள பெரும்பாலான கருவிகளைக் கொண்டு இவ்வாறான கணினிமொழி பொதுமக்களின் பயன்பாட்டிற்கு கிடைக்காது ஆனால் போனி எனும் மொழி அவ்வாறான கூற்றினை பொய்யாக்கி பொதுமக்களும் அவ்வாறான எளிதாக கையாளும் போனிமொழியாக நாம் பயன்படுத்தி கொள்ளதயாராக இருக்கின்றது இந்த போனி எனும்கணினிமொழியானது வகைகளில் -பாதுகாப்பானது ,நினைவகபயன்பாட்டில்-பாதுகாப்பானது, விதிவிலக்குகளில்-பாதுகாப்பானது,தரவுஓட்டத்தில் விரைவானது ,இதனை எதனாலும் முடக்கமுடியாது கூடுதலாக, இது திறமையான சொந்த குறியீட்டிற்காக தொகுக்கப்பட்டுள்ளது , மேலும் இது இரண்டு-பிரிவு BSD உரிமத்தின் கீழ் கட்டற்ற வகையில் நாம் பயன்படுத்த தயாராக உள்ளது.
இந்த போனி எனும் கணினிமொழியானது நம்மை பாதுகாப்பான, திறமையான, மிகவும் உற்சாகமான ஆகிய நான்கு இலக்குகளை எளிதாக அடையுமாறு செய்துவிடுகின்றது
பொருள் நோக்கு நிரலாக்க பொருட்களில் உள்ள பொருட்கள் + ஒத்திசைவு வழிமுறைகள் + ஒத்திசைவற்றநெறி வழிமுறைகள் ஆகியவை அனைத்தும் ஒன்றிணைந்த actor model என்பதன் வாயிலாகவே அனைத்து செயல்களையும் இந்த கணினிமொழி செயல்படுத்திடுகின்றது அதனால்இது மிகச்சிறந்த கணினிமொழியாக விளங்குகின்றது மேலும் இது கணினியின் மையசெயலகத்தை மிகத்திறனுடன் விரைவாக கையாளுகின்றது இதன் விளைவாக, போனியின் நிரல்தொடர்கள் மிகவும் சீரான செயல்திறன் மற்றும் கணிக்க முடியாத நிலைத்தன்மைகளுடன் உருவாகின்றன இது தனியாக தரவு பாதுகாப்பு பகுதியை உருவாக்குகிறது. அதனால் நம்முடைய நிரல்தொடர் பாதுகாப்பானதாக விளங்குகின்றதுநம்முடைய குறிமுறைவரிகள் மிகவிரைவாகவும் எதனாலும் முடக்க முடியாததாகவும் அமைக்கின்றது
ஒருசிக்கலானபிரச்சினைகளை தீர்வுசெய்வதற்கான அல்லது கடினமான பணியைதீர்வுசெய்வதற்கான நிரல்தொடரைமிகஎளிதாக இதில்உருவாக்கிடலாம்
இந்த போனி எனும்கணினிமொழியை அறிந்து கொள்ள விரும்பினால் https://www.ponylang.org/learn/ எனும் இணைய பக்கத்திற்குசெல்க

பைத்தான் மொழியினுடையசெயலியின் மூலக்குறிமுறைவரிகளைஎவ்வாறு திரும்பெறுவது


ஒருசில நேரங்களில் பைத்தானின் ஒரு சிலசெயலிகளின் மூலக்குறிமுறைவரிகள் எவ்வாறு அமைந்திருக்கும் என நாம் அறிந்து கொள்ள விழைவோம் அல்லது அவை எங்கிருக்கும் என அறிந்து கொள்ளவிழைவோம் அல்லது அந்த மூலக்குறிமுறைவரிகளை எழுத்துசரங்களாக மாற்றியமைத்திடுவதற்கு விரும்புவோம் இவ்வாறான நிலையில் இந்த பைத்தானின் செயலிகளின் மூலக்குறிமுறைவரிகளைஎப்படியாவது திரையில் கொண்டுவந்து காண ஆவலாக இருப்போம் நிற்க இதற்காக இந்த கணினிமொழியின்inspect எனும்முன்கூட்டியே கட்டமைக்கப் பட்ட சொந்த செந்தர நூலகமும் dillஎனும்மூன்றாவது நபரின் நூலகமும் உதவுகின்றன பொதுவாக நம்முடையகணினியில் பைத்தான் மொழியை நிறுவுகை செய்திடும் போதே inspect எனும் செந்தர நூலகமும் நிறுவுகைசெய்யப்பட்டுவிடும் இதிலுள்ள modules, classes, methods, functions, tracebacks, frame objects, code objects போன்ற பயனுள்ள செயலிகள் பல்வேறு வகையான தகவல்களைபெறத்தயாராக இருக்கின்றன அதைவிட இவைகளை கொண்டு குறிப்பிட்டசெயலியின் மூலக்குறிமுறைவரிகளை கூட கொண்டுவந்து திரையில் காண்பிக்குமாறு செய்திடமுடியும்
In [1]: importpandas
importinspect
In [3]: source_DF=inspect.getsource(pandas.DataFrame)
print(type(source_DF))
<>
In [4]: print(len(source_DF))
218432
In [5]: print(source_DF[:200])
class DataFrame(NDFrame):
“””Two-dimensional size-mutable, potentially heterogeneous tabulardata
structurewith labeled axes (rows and columns). Arithmetic operations
align on both row a
In [6]: source_file_DF=inspect.getsourcefile(pandas.DataFrame)
print(source_file_DF)
D:\Users\dengdong\AppData\Local\Continuum\anaconda3\lib\site-packages\pandas\core\frame.py
In [7]: sourcelines_DF=inspect.getsourcelines(pandas.DataFrame)
print(type(sourcelines_DF))
print(len(sourcelines_DF))
print(type(sourcelines_DF[0]))

2

மேலும் பின்வரும் Ipythonஅல்லதுJupyterதுனையுடன் பைத்தானின் மூலக்குறிமுறை-வரிகளை கொண்டு வந்து திரையில் காண்பிக்குமாறு செய்திடுகின்றது
In [9]: deftest(x):
returnx*2
print(inspect.getsource(test))
def test(x): return x*2
In [10]: print(inspect.getsourcefile(test))

In [11]: print(inspect.getsourcelines(test))
([‘def test(x):\n’, ‘ return x*2\n’], 1)
பின்வரும்dillஎன்பது பைத்தானினஅ மூலக்குறிமுறைவரிகளைகொண்டுவந்து திரையில் காண்பிக்குமாறு செய்திடுகின்றது
In [6]: importdill
source_DF=dill.source.getsource(pandas.DataFrame)
print(type(source_DF))
print(len(source_DF))
print(source_DF[:200])
source_file_DF=dill.source.getsourcefile(pandas.DataFrame)
print(source_file_DF)
sourcelines_DF=dill.source.getsourcelines(pandas.DataFrame)
print(type(sourcelines_DF))
print(len(sourcelines_DF))
print(type(sourcelines_DF[0]))

195262
classDataFrame(NDFrame):
“”” Two-dimensional size-mutable, potentially heterogeneous tabular data
structure with labeled axes (rows and columns). Arithmetic operations
align on both row a
/Users/XD/anaconda/lib/python2.7/site-packages/pandas/core/frame.py

2

சாதரான பைத்தான் குறிமுறைவரிகளை கொண்டு மூலக்குறிமுறைவரிகளை கொண்டுவர இந்த dillஎன்பது பெரிதும்பயன்படுகின்றது

Previous Older Entries