உண்மையில் லுவா ஆனது ஒரு பொருள் நோக்கு நிரலாக்க மொழி அன்று, ஆனால் சி இன் செயலிகள் சி மொழி- போன்ற இலக்கணம் ஆகியவற்றைப் பயன்படுத்தி கொள்கின்ற உரைநிரல்மொழி. இருப்பினும், நமக்குத் தேவைப்படும்போது லுவாவை ஒரு பொருள்நோக்கு மொழியாகச் செயல்பட லுவா குறிமுறைவரிகளில் பயன்படுத்தக்கூடியசிறந்த குறும்பானசெயல் ஒன்றுஉள்ளது. திறவுகோலானது லுவா அட்டவணை கட்டமைப்பில் உள்ளது, மேலும் இந்த கட்டுரை ஒரு பொருள்நோக்கு இனத்திற்கு லுவா அட்டவணையை எவ்வாறு பயன்படுத்த வேண்டும் என்பதற்கான விளக்கமளிக்கிறது.
பொருள்நோக்கு நிரலாக்கம் என்றால் என்ன?
“பொருள்நோக்கு(object-oriented)” என்ற சொல், அடிப்படையில், ஒருமாதிரிப்பலக அமைவை விவரிக்கின்ற ஒரு ஆடம்பரமான வழியாகும். zombie apocalypse இன் போது பயனாளர்கள் zombiesஐ கண்டறிந்து பதிவுசெய்ய உதவும் ஒரு பயன்பாட்டை நிரலாக்கம் செய்வதாக கற்பனை செய்திடுக. இதற்காக நாம் C++, Java அல்லது Python போன்ற பொருள்நோக்கு மொழியைப் பயன்படுத்திடுவோம். பல்வேறு வகையான ஜோம்பிஸைக் குறிக்கும் குறிமுறைவரியில் பொருட்களை உருவாக்க வேண்டும், இதனால் பயனாளர் அவற்றை இழுத்து நகரத்தின் வரைபடத்தில் சரி செய்திடலாம். நிச்சயமாக ஒரு ஜாம்பி பல செய்திகளாக இருக்கலாம்: செயலற்ற, மெதுவாக, விரைவான, பசியுடனான, கொடுங் கொள்ளை யடிக்கின்ற என்பதுபோன்ற பல. இது வெறும் உரைத் தரவு, எந்தக் கணினிகள் கண்காணிப்பதில் சிறந்தவை, அந்தத் தரவின் அடிப்படையில் மெய்நிகரான “பொருளுக்கு” ஒரு வரைகலைைக் கூட ஒதுக்கலாம், எனவே பயனாளர் ஒவ்வொரு widgetஉம் எந்த வகையான ஜாம்பியைக் குறிக்கிறது என்பதைக் கண்டறிய முடியும். பயன்பாட்டிற்கான இந்தத் தேவையை எவ்வாறு தீர்வுசெய்திடலாம் என்பதற்கான சில வாய்ப்புகள் நம்மிடம் உள்ளன:
1.நம்முடைய பயனாளர்கள் தங்கள் சொந்த ஜோம்பிஸை நம்முடைய பயன்பாட்டில் நிரலாக்கம் செய்வது எப்படி என்பதை அறியும்படி கட்டாயப்படுத்திடுக.அதனால் அவர்கள் தங்கள் சொந்த ஜாம்பிகளை உங்கள் பயன்பாட்டில் நிரல்படுத்த முடியும்
.2.வாழ்நாள் முழுவதையும் நம்முடைய பயன்பாட்டில் சாத்தியமான ஒவ்வொரு வகையான ஜாம்பியையும் நிரலாக்கத்தில் செலவிடுக.
. 2. 3.ஜோம்பி எனும்பொருளின் பண்புகளை வரையறுக்க குறிமுறைவரிகளினஅ மாதிரிபலகத்தைப் பயன்படுத்திடுக, பயனார்கள் அவர்கள் உண்மையில் கண்டறிந்த ஜாம்பியின் அடிப்படையில் அவர்களுக்குத் தேவையான பொருட்களை உருவாக்க அனுமதிக்கிறது.
வெளிப்படையாக, ஒரே யதார்த்தமான வாய்ப்பு இறுதியானதாகும், மேலும் இது வகுப்பு எனப்படும் நிரலாக்க கட்டமைப்பைக் கொண்டு செய்யப்படுகிறது. ஒரு வகுப்பு எப்படி இருக்கும் என்பது பின்வரும்பகுதியில் கொடுக்கப்பட்டுள்ளது (இந்த எடுத்துக்காட்டு ஜாவா குறிமுறைவரிகளாக இருக்கும், ஆனால் அனைத்து பொருள் நோக்கு மொழிகளிலும் கருத்தமைவு ஒரே மாதிரியாக இருக்கும்):
public class Zombie {
int height;
int weight;
String speed;
String location;
}
நாம் இந்த குறிமுறைவரிகளை புரிந்து கொண்டாலும் இல்லாவிட்டாலும், இது அடிப்படையில் ஒரு மாதிரிபலகம் என்று கூறலாம். ஒரு ஜாம்பியை பிரதிநிதித்துவப்படுத்த ஒரு மெய்நிகர் “பொருள்” உருவாக்கப்பட்டால், நிரலாக்க மொழி அந்த பொருளுக்கு நான்கு பண்புகளை (உயரத்தையும், எடையையும் குறிக்கும் இரண்டு முழு எண்கள் , இயக்கத்தின் வேகம் அதன் இருப்பிடத்தைக் குறிக்கும் இரண்டு சொற்கள்) ஒதுக்குகிறது என்று அது அறிவிக்கிறது. (கற்பனையாக) பயன்பாட்டில் உள்ள (imaginary) Add item எனும் பொத்தானை சொடுக்குதல் செய்யும் போது, பயனார் உள்ளிட்ட மதிப்புகளை ஒதுக்க, இந்த வகுப்பு ஒரு மாதிரிப்பலகமாகப் பயன்படுத்தப்படுகிறது (நிரலாக்கத்தில், வகுப்பின் “new instance” ஒன்று உருவாக்கப்பட்டது என்று கூறுகிறார்கள்). . ஒரு வகுப்பின் விலையில் எல்லையற்ற ஜோம்பிஸ். இது பொருள் நோக்கு நிரலாக்கத்தின் திறன்களில் ஒன்றாகும்.
லுவா அட்டவணைகள் லுவாவில், அட்டவணை என்பது ஒரு துணை அணிவரிசையை செயல்படுத்தும் தரவு வகையாகும். லுவாவில் உள்ள அட்டவணையை தரவுத்தளமாககூட நினைக்கலாம். இது ஒரு சிறப்பு இலக்கணத்தின் மூலம் நினைவுபடுத்தக்கூடிய அட்டவணைப்படுத்தப்பட்ட தகவல்களின் கிடங்காகும். அதற்கான ஒரு மிக எளிய உதாரணம்பின்வருமாறு:
example = {}
example.greeting = “hello”
example.space = ” ”
example.subject = “world”
print(example.greeting ..
example.space ..
example.subject)
இதன் முடிவுகளைக் காண எடுத்துக்காட்டுக் குறிமுறைவரிகளை இயக்கிடுக:
$ lua ./example.lua
hello world
மாதிரிக் குறிமுறைவரிகளிலிருந்து சொல்லக்கூடியது போன்றஉ, அட்டவணை என்பது ஒற்றையான தொகுப்பில் (ஒரு “அட்டவணை”) வைக்கப்பட்டுள்ள விசைகள் , மதிப்புகளின் தொகுப்பாகும்.
லுவாவின் மீப்பெரும்அட்டவணை (metatable)
ஒரு மீப்பெரும்அட்டவணை (metatable) என்பது ஒரு அட்டவணைக்கு ஒரு மாதிரிபலகமாக செயல்படும் வழக்கமானதொருஅட்டவணை ஆகும். நாம் எந்த அட்டவணையையும் மீப்பெரும்அட்டவணை (metatable) என குறிப்பிடலாம், பின்னர் வேறு எந்த மொழியிலும் உள்ள வகுப்பைப் போலவே அதையும் கையாளலாம். ஒரு ஜாம்பியை வரையறுக்க மீப்பெரும்அட்டவணை (metatable) பின்வருமாறு:
Zombie = {}
function Zombie.init(h,w,s,l)
local self = setமீப்பெரும்அட்டவணை (metatable)({}, Zombie)
self.height = h
self.weight = w
self.speed = s
self.location = l
return self
end
— use the மீப்பெரும்அட்டவணை (metatable)
function setup()
z1 = Zombie.init(176,50,’slow’,’Forbes & Murray Avenue’)
end
function run()
print(z1.location .. “: ” ..
z1.height .. ” cm, ” .. z1.weight .. ” kg, ” .. z1.speed)
end
setup()
run()
இந்த மீப்பெரும்அட்டவணை (metatable)ஐ ஒரு சாதாரண அட்டவணையில் இருந்து வேறுபடுத்த, அதன் பெயரின் முதல் எழுத்தை பெரியதாக்கிடுத. அது தேவையில்லை, ஆனால் இது ஒரு பயனுள்ள வழக்கமாகக் கருதப்படுகிறது. மாதிரிக் குறிமுறைவரிகளின் முடிவுகள் பின்வருமாறு:
$ lua ./zombie.lua
Forbes & Murray Avenue: 176 cm, 50 kg, slow,
மெதுவாக இந்த ஆர்ப்பாட்டம் முழுவதுமாக மீப்பெரும்அட்டவணை (metatable)களுக்கு நீதி வழங்காது, ஏனெனில் மாதிரி குறிமுறைவரிகள் பயனரிடமிருந்து எந்த தொடர்பும் இல்லாமல் ஒரு பொருளை மட்டுமே உருவாக்குகிறது. ஒரே ஒரு மீப்பெரும்அட்டவணை (metatable)இல் இருந்து எல்லையற்ற உருப்படிகளை உருவாக்கும் சிக்கலைத் தீர்வுசெய்திட, மீப்பெரும்அட்டவணை (metatable)ஐ பயன்படுத்த, அதற்குப் பதிலாக பயனாளர் உள்ளீட்டு செயலை (Lua’s io.read() செயலியைப் பயன்படுத்தி) குறிமுறைவரிகளாக்கி, அவர்கள் கண்டறிந்த ஜாம்பியின் விவரங்களை வழங்குமாறு பயனாளரிடம் கோரிடுவோம். பயனாளர் இடைமுகத்தை “New sighting” எனும்பொத்தான் அல்லது அது போன்ற ஏதாவது ஒன்றைக் கொண்டு குறிமுறைவரிகளில் செய்யலாம். அது இந்தக் கட்டுரையின் எல்லைக்கு அப்பாற்பட்டது, மேலும் இது எடுத்துக்காட்டுக் குறிமுறைவரிகளை சிக்கலாக்கும்.
ஒரு மீப்பெரும்அட்டவணை (metatable) உருவாக்குதல். நினைவில் கொள்ள வேண்டிய முக்கியமான செய்தி என்னவென்றால், ஒரு மீப்பெரும்அட்டவணை (metatable) உருவாக்க, பின்வருமாறான இலக்கணத்தினஐ பயன்படுத்திகொள்க:
Example = {}
function Example.init(args)
local self = setமீப்பெரும்அட்டவணை (metatable)({}, Example)
self.key = value
return self
end
ஒரு மீப்பெரும்அட்டவணை (metatable)ஐ பயன்படுத்துதல்
மீப்பெரும்அட்டவணை (metatable) உருவாக்கப்பட்டவுடன் அதைப் பயன்படுத்த, பின்வருமாறான இலக்கணத்தினை பயன்படுத்திகொள்க:
my_instance = Example.init(“required args”)
பொருள்நோக்கு Lua:Lua பொருள் நோக்கு மொழிஅன்று, ஆனால் அதன் அட்டவணை தொழில்நுட்பம் தரவைக் கையாளுதல் , கண்காணிப்பு, வரிசைப்படுத்துதல் போன்றவற்றை எளிதாக்குகிறது. லுவாவில் அட்டவணைகளைகையாளும் திறனுடன் இருந்தால், குறைந்தபட்சம் பாதி மொழியாவது நமக்குத் தெரியும் என்று நம்பலாம் என்று சொன்னால் அது மிகையாகாது. அட்டவணைகளை ( நீட்டிப்பு மூலம், மெட்டாட்டபிள்கள்) அணிவரிசைகள், வரைபடங்கள், வசதியான மாறியின் அமைப்பு, நெருக்கமான வகுப்புகள் போன்ற பலவற்றைப் பயன்படுத்தலாம்.