செயற்கூறிய நிரலாக்கம் – உயர்வரிசை செயற்கூறுகள் – பகுதி 3

கீழேயுள்ள நிரலிலுள்ளதைப்போன்ற செயற்கூறுகளை நமது அன்றாட நிரலாக்கப்பணியில் கண்டிருப்போம்.

function validateSsn(ssn) {
    if (/^\d{3}-\d{2}-\d{4}$/.exec(ssn))
        console.log('Valid SSN');
    else
        console.log('Invalid SSN');
}
function validatePhone(phone) {
    if (/^\(\d{3}\)\d{3}-\d{4}$/.exec(phone))
        console.log('Valid Phone Number');
    else
        console.log('Invalid Phone Number');
}

அடிப்படையில், இவ்விரு செயற்கூறுகளும் ஒரேவேலையைத்தான் செய்கின்றன. அதாவது, கொடுக்கப்பட்ட மதிப்பை (ssn / phone), ஒரு செங்கோவையைக்கொண்டு (RegularExpressions) சரிபார்த்து, அதன் விடையை அச்சிடுகின்றன. எனவே, இவ்விரு செயற்கூறுகளுக்குப்பதிலாக ஒரு செயற்கூற்றைமட்டும் வரையறுத்து, மாறுபடுகின்ற மதிப்புகளை உள்ளீட்டு உருபுகளாக அளிக்கலாம். இதனால் validateSsn, validatePhone என்ற இருசெயற்கூறுகளுக்குப்பதிலாக, validateValue என்ற ஒரே செயற்கூறு போதுமானதாகிறது.

function validateValue(value, regex, type) {
    if (regex.exec(value))
        console.log('Invalid ' + type);
    else
        console.log('Valid ' + type);
}
  • value என்ற உள்ளீட்டு உருபு ssn, phone ஆகிய மதிப்புகளுள் ஒன்றை ஏற்கிறது.
  • /^\d{3}-\d{2}-\d{4}$/ மற்றும் /^\(\d{3}\)\d{3}-\d{4}$/ ஆகிய செங்கோவைகளுள் ஒன்று regex என்ற உள்ளீட்டு உருபுக்கு மதிப்பாக அனுப்பப்படுகிறது.
  • இறுதியாக, type என்ற உருபு SSN, Phone Number ஆகிய மதிப்புகளுள் ஒன்றை ஏற்கிறது.

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

இதேபோன்ற இன்னுமிரு செயற்கூறுகளை எடுத்துக்கொள்ளலாம். இவையும் மேலேகண்ட இரு செயற்கூறுகளைப்போலவே செயல்படுகின்றது. ஒரேயொரு வேறுபாடு என்னவெனில், இங்கே செங்கோவைகளின் இடத்தை, parseAddress, parseName என்ற இருவேறு செயற்கூறுகள் எடுத்துக்கொள்கின்றன. இதனை மறுபகுப்பு (Refactor) செய்யமுயல்வோம்.

function validateAddress(address) {
    if (parseAddress(address))
        console.log('Valid Address');
    else
        console.log('Invalid Address');
}
function validateName(name) {
    if (parseFullName(name))
        console.log('Valid Name');
    else
        console.log('Invalid Name');
}

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

செயற்கூறிய நிரலாக்கத்தில் செயற்கூறுகள் முதல்தர குடிமக்களாகக்கருதப்படுகின்றன.

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

function validateValueWithFunc(value, parseFunc, type) {
    if (parseFunc(value))
        console.log('Invalid ' + type);
    else
        console.log('Valid ' + type);
}

நமது புதிய செயற்கூறு (validateValueWithFunc) ஓர் உயர்வரிசை செயற்கூறாகும் (Higher order functions).

செயற்கூறுகளை உள்ளீட்டு உருபாகவோ, திருப்பியனுப்பும் மதிப்பாகவோகொண்ட செயற்கூறுகளுக்கு உயர்வரிசை செயற்கூறுகள் என்று பெயர்.

நமது புதிய செயற்கூற்றைப்பயன்படுத்தி, மேற்கண்ட நான்கு செயற்கூறுகளையும் மறுபகுப்பு செய்யலாம்.

validateValueWithFunc('123-45-6789', /^\d{3}-\d{2}-\d{4}$/.exec, 'SSN');
validateValueWithFunc('(123)456-7890', /^\(\d{3}\)\d{3}-\d{4}$/.exec, 'Phone');
validateValueWithFunc('123 Main St.', parseAddress, 'Address');
validateValueWithFunc('Joe Mama', parseName, 'Name');

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

செங்கோவைகளைப் பொருத்திப்பார்க்கும் கூற்றை ஒரு செயற்கூறாகப் பிரித்தெடுக்கலாம்.

var parseSsn = /^\d{3}-\d{2}-\d{4}$/.exec;
var parsePhone = /^\(\d{3}\)\d{3}-\d{4}$/.exec;

validateValueWithFunc('123-45-6789', parseSsn, 'SSN');
validateValueWithFunc('(123)456-7890', parsePhone, 'Phone');
validateValueWithFunc('123 Main St.', parseAddress, 'Address');
validateValueWithFunc('Joe Mama', parseName, 'Name');

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

function makeRegexParser(regex) {
    return regex.exec;
}

var parseSsn = makeRegexParser(/^\d{3}-\d{2}-\d{4}$/);
var parsePhone = makeRegexParser(/^\(\d{3}\)\d{3}-\d{4}$/);

இங்கே makeRegexParser என்ற செயற்கூறு ஒரு செங்கோவையை உள்ளீட்டு உருபாக எடுத்துக்கொண்டு, செங்கோவையைப்பொருத்திப்பார்க்கும் செயற்கூற்றைத்திருப்பியனுப்புகிறது.

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

function makeAdder(constantValue) {
    return function adder(value) {
        return constantValue + value;
    };
}

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

இதனைக் கீழ்கண்டவாறு பயன்படுத்தலாம்.

var add10 = makeAdder(10);
console.log(add10(20)); // 30ஐ அச்சிடுகிறது
console.log(add10(30)); // 40ஐ அச்சிடுகிறது
console.log(add10(40)); // 50ஐ அச்சிடுகிறது

makeAdderக்கு 10 என்ற உள்ளீட்டையளித்து, add10 என்ற செயற்கூற்றைப்பெறலாம். add10 செயற்கூறு அதற்கு கொடுக்கப்பட்ட மதிப்புடன் பத்தைக்கூட்டி விடையைத்தருகிறது. இங்கே கவனிக்கப்படவேண்டிய விசயம் என்னவென்றால், நாம் makeAdderக்கு உள்ளீடாக அளித்த 10 என்ற மதிப்பை, add10 செயற்கூற்றால் அணுகமுடிகிறது. இதற்கு closure என்றுபெயர்.

அடுத்தபகுதியில் closureஐப்பற்றி விரிவாககாணலாம்.

மூலம்: Charles Scalfani எழுதிய கட்டுரைத்தொடரின் தமிழாக்கம். அவரது அனுமதியோடு மொழிபெயர்க்கப்பட்டுள்ளது.

1 Comment

  1. cosmo (@cosmo_bird)

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

    Reply

Leave a Reply

%d bloggers like this: