செயற்கூறிய நிரலாக்கம் – பொதுவான செயற்கூறிய செயற்கூறுகள் – பகுதி 7

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

நமக்கு நன்கு பரிச்சயமான, எளிமையான ஜாவாஸ்கிரிப்ட்டு நிரலிலிருந்து தொடங்கலாம்.

for (var i = 0; i < something.length; ++i) {
    // do stuff
}

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

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

var things = [1, 2, 3, 4];
for (var i = 0; i < things.length; ++i) {
    things[i] = things[i] * 10; // நிலைமாற்ற எச்சரிக்கை!!
}
console.log(things); // [10, 20, 30, 40]

இங்கே things இன் உருப்படிகளை (items) மாற்றியமைக்கிறோம். ஆனால், செயற்கூறிய நிரலாக்கத்தில் நிலைமாறாத்தன்மையைக் கடைபிடிக்கவேண்டுமே! சரி, நிரலை சற்றே மாற்றியெழுதிப்பார்க்கலாம்.

var things = [1, 2, 3, 4];
var newThings = [];
for (var i = 0; i < things.length; ++i) {
    newThings[i] = things[i] * 10;
}
console.log(newThings); // [10, 20, 30, 40]

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

var map = (f, array) => {
    var newArray = [];
    for (var i = 0; i < array.length; ++i) {
        newArray[i] = f(array[i]);
    }
    return newArray;
};

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

var things = [1, 2, 3, 4];
var newThings = map(v => v * 10, things);

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

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

var filter = (pred, array) => {
	var newArray = [];
	for (var i = 0; i < array.length; ++i) {
        if (pred(array[i]))
            newArray[newArray.length] = array[i];
	}
	return newArray;
};

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

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

var isOdd = x => x % 2 !== 0;
var numbers = [1, 2, 3, 4, 5];
var oddNumbers = filter(isOdd, numbers);
console.log(oddNumbers); // [1, 3, 5]

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

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

var reduce = (f, start, array) => {
    var acc = start;
    for (var i = 0; i < array.length; ++i)
        acc = f(array[i], acc); // f() இரண்டு உருபுகளை ஏற்கவேண்டும்.
    return acc;
});

மேற்கண்ட இருசெயற்கூறுகளும், ஒருசெயற்கூற்றையும் (f / pred), உருப்படிகளின் வரிசையையும் (array) உள்ளீட்டுஉருபாக ஏற்றன. ஆனால், reduce செயற்கூற்றுக்கு இவற்றோடு start என்ற தொடக்கமதிப்பையும் உள்ளீடாக அளிக்கவேண்டும். மேலும், reduce செயற்கூற்றுக்கு உள்ளீடாக அளிக்கப்பட்ட f செயற்கூறு இரண்டு உள்ளீட்டுஉருபுகளை ஏற்கக்கூடியதாக இருக்கவேண்டும். இதனைத்தெளிவாகப்புரிந்துகொள்ள ஓர் எடுத்துக்காட்டைப் பார்க்கலாம்.

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

var add = (x, y) => x + y;
var values = [1, 2, 3, 4, 5];
var sumOfValues = reduce(add, 0, values);
console.log(sumOfValues); // 15

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

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

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

Leave a Reply

%d bloggers like this: