எளிய, இனிய கணிணி மொழி – ரூபி – 7- ரூபி செயற்கூறுகள்

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

பிற மொழிகளில் உள்ள Function என்பதையே இங்கு Method என்கிறோம்.

ரூபி செயற்கூற்றை உருவாக்குதல் மற்றும் அழைத்தல்:

ரூபி செயற்கூறின் அமைப்பு (syntax) பின்வருமாறு.

def name( arg1, arg2, arg3, ... )
   .. ruby code ..
   return value
end

இதில் name ஆனது செயற்கூறின் பெயர் ஆகும். பெயரைப் பயன்படுத்தியே செயற்கூற்றை அழைக்க வேண்டும். Arguments ஆனது செயற்கூறு செயல்படத்தேவையான மதிப்பை அனுப்புவதாகும். Ruby code என்பது செயற்கூற்றின் அங்கமாகும் (body). செயல்பாடு இங்கே நடைபெறும். Return statement கட்டயமானதல்ல, இது நிரலில் செயற்கூற்றை அழைக்குமிடத்திற்கு மதிப்பை திருப்பி அனுப்பும்.

ஒரு சரத்தை பதிப்பிக்கும் (string display) செயற்கூற்றை உருவாக்குதல் மற்றும் அழைத்தல் எப்படியென பார்க்கலாம்.

def saysomething
    puts "Hello"
end

saysomething
=> "Hello"

method_definition_calling

செயற்கூறிற்கு arguments அனுப்புதல்:

மேலே உள்ள எடுத்துக்காட்டில் செயற்கூறு எந்த argument-ஐயும் ஏற்கவில்லை. Arguments மதிப்பை கொண்டு செயற்கூறில் கணக்கீடு செய்வதை பின்வரும் எடுத்துக்காட்டில் பார்க்கலாம்.

def multiply(val1, val2 )</span></span>
     val1 * val2
end

multiply 2, 10   # 20
multiply 4, 20   # 80
multiply 10, 40   # 400
multiply 6, 7   #42

method_reuse

இந்த எடுத்துக்காட்டில், செயற்கூறு பலமுறை அழைக்கப்பட்டுள்ளது. இதில் arguments-யை அனுப்ப, அதை செயற்கூறில் கணக்கீடல் செய்து விடையைத் தருகிறது. இதை செயற்கூறு இல்லாமல் செய்ய வேண்டுமானால் இந்த நிரலை 4 முறை எழுத வேண்டியதிருக்கும். ஆதலால் நிரலை செயற்கூறில் வைப்பதானால் நிரல் மறுபயன்பாடு (reusability) செய்யப்படுகிறது. இது ஒரு சிறந்த வழியாகும்.

செயற்கூறிற்கு பல்வேறு arguments-யை அனுப்புதல்:

முந்தைய பகுதில், ஒரு குறிப்பிட்ட, நிலையான எண்ணிக்கை கொண்ட arguments-யே செயற்கூறு எடுத்துக்கொண்டது. சிலநேரங்களில் எவ்வளவு arguments தேவை என்பது நமக்கே தெரியாது. இதை *args-யை கொண்டு செய்யலாம். செயற்கூற்றை உருவாக்கும்போது இதை கொடுக்க வேண்டும். arguments-ஆக அனுப்பப்படும் மதிப்பை array-ல் வைத்து செயற்கூறில் பயன்படுத்தலாம்.

def displaystrings( *args )
         args.each {|string| puts string}
end

displaystrings("Red")
Red

displaystrings("Red", "Green")
Red
Green

displaystrings("Red", "Green", "Blue")
Red
Green
Blue

passing_multiple_arguments

செயற்கூறிலிருந்து விடையை திருப்பி அனுப்புதல்:

Return statement-டை பயன்படுத்தி செயற்கூறிலிருந்து மதிப்பை திருப்பி அனுப்பமுடியும். ஒரு செயற்கூறு திருப்பியனுப்பும் மதிப்பை assignment(=) operator-ஐ கொண்டு பெற வேண்டும். பின்வரும் எடுத்துக்காட்டில், செயற்கூறு, arguments-லிலுள்ள மதிப்பை பெருக்கல் செய்து விடையை திருப்பி அனுப்புகிறது.

def multiply(val1, val2 )
    result = val1 * val2
    return result
end
value = multiply( 10, 20 )
puts value

return_from_method

மேலே உள்ள எடுத்துக்காட்டில் 10 மற்றும் 20, arguments ஆக multiply method-க்கு அனுப்பபடுகிறது. செயற்கூறானது மதிப்பை பெருக்கல் செய்து அதன் விடையை திருப்பி அனுப்புகிறது. திருப்பி அனுப்படும் விடை ஒரு மாறியில் (variable) வைக்கப்படுகிறது. அப்புறம் அதை puts-யை பயன்படுத்தி காட்சிப்படுத்தப்படுகிறது.

இதில் கவனிக்க வேண்டிய விசயம், செயற்கூறு ஒரேயொரு மதிப்பை அல்லது object-டைதான் திருப்பி அனுப்பும். நிறைய மதிப்பை திருப்பி அனுப்ப வேண்டுமெனில் ஒரு array வைத்து அனுப்ப வேண்டும்.

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

def multiply(val1, val2 )
     val1 * val2
end

multiply 10, 20 # 200

need_not_return_explicitly

ரூபி செயற்கூறிற்கு வேறுபெயர்(aliases) வைத்தல்:

ரூபி, செயற்கூறிற்கு வேறுபெயர் வைக்க அனுமதிக்கும். அவ்வாறு வேறுபெயர் வைக்கும் பொழுது, ரூபி, அந்த செயற்கூறிற்கு ஒரு நகலை உருவாக்கி அதற்கு இந்த புதிய பெயரை வைத்துவிடும். (இரண்டு பெயர்களையும் கொண்டு அந்த செயற்கூற்றை அழைக்க முடியும்) உதாரணத்திற்கு,

def multiply(val1, val2 )
     result = val1 * val2
     return result
end

alias docalc multiply

docalc( 10, 20 ) # 200

multiply( 10, 20 ) # 200

method_alias

இவ்வாறு நகல்களை உருவாக்கி பயன்படுத்துதல், ரூபியின் பொதுவான பயன்பாடாகும். ஏற்கனவே வரையறுக்கப்பட்ட செயற்கூறில் மாற்றங்கள் செய்தால், அது இந்த புதிய நகலில் பிரதிபலிக்காது.

def multiply(val1, val2 )
     val1 * val2
end

alias docalc multiply

docalc 10, 20 # 200
multiply 10, 20 # 200

def multiply(val1, val2)
    p “This method adds two numbers”
    val1 + val2
end

docalc 10, 20 # 200
multiply 10, 20
=> “This method adds two numbers”
=> 30

use_of_alias_method

மேற்கண்ட உதாரணத்தில், multiply செயற்கூற்றின் வரையறையை மாற்றிய பிறகும், docalc செயற்கூறு பழைய வரையறையின்படி இயங்குவதைக்காணலாம்.

மூன்றாம் தரப்பு (third party) library-களை பயன்படுத்தும்பொழுது, அவற்றிலுள்ள செயற்கூற்றின் வரையறையை மாற்றி, நம்தேவைகேற்ப, கூடுதல் செயல்பாட்டை உட்புகுத்த இந்த முறையை பயன்படுத்தலாம். multiply செயற்கூறு ஒரு மூன்றாம் தரப்பு library-யிலிருக்கிறது எனவும், அதன் வரையறை நமக்கு தெரியவில்லையென வைத்துக்கொள்வோம். இந்த செயற்கூறு என்ன செய்கிறது என ஒரு print statment-ஐ இதனுடன் இணைக்கவேண்டும் என வைத்துக்கொள்வோம். multiply செயற்கூறிற்கு ஒரு நகலை உருவாக்கி, multiply-யை மறுவரையறை செய்வதன்மூலம், நமக்குவேண்டிய மாற்றங்களை செய்துகொள்ளலாம்.

def multiply(val1, val2 )
     val1 * val2
end

alias docalc multiply

docalc 10, 20 # 200
multiply 10, 20 # 200

def multiply(val1, val2)
    p “This method multiplies two numbers”
    docalc val1, val2
end

docalc 10, 20 # 200
multiply 10, 20
=> “This method multiplies two numbers”
=> 200

redefine_alias_method

— தொடரும்

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

%d bloggers like this: