செயற்கூறிய நிரலாக்கம் – செயற்கூறிய ஜாவாஸ்கிரிப்ட்டு – பகுதி 10

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

செயற்கூறிய ஜாவாஸ்கிரிப்ட்டு

செயற்கூறிய முறையில் நிரலெழுத ஏதுவான, நிலைமாறாத்தன்மை போன்ற, சில அம்சங்களை ஜாவாஸ்கிரிப்ட்டு நமக்குத்தருகிறது. மேலும் சிலவற்றை மாற்றந்திரட்டுகள் மூலமாக நாம் பெறமுடியும்.

நிலைமாறாத்தன்மை

ஜாவாஸ்கிரிப்ட்டின் ES6 பதிப்பில், const என்ற புதிய திறவுச்சொல் அறிமுகப்படுத்தப்பட்டுள்ளது. இதைக்கொண்டு நிலைமாறாத்தன்மையை அடையமுடியும்.

const a = 1;
a = 2;

இங்கே a மாறிலியாக வரையறுக்கப்பட்டுள்ளது. எனவே அதன் மதிப்பை மாற்றமுடியாது.

ஆனால், const-ல் சில குறைபாடுகள் உள்ளன. அதாவது, a-ஐ ஒரு பொருளாக வரையறுத்தபின், அதன் நிலையை மாற்றமுடியும்.

const a = {
    x: 1,
    y: 2
};
a.x = 2; // மாற்றமுடியும்!
a = {}; // மாற்றமுடியாது!!

இங்கே a என்பதுமட்டுமே மாறிலியாக இருக்கிறது. x, y ஆகியன மாறிகளாகவே உள்ளன.

Immutable.js என்ற திரட்டின் வாயிலாக ஜாவாஸ்கிரிப்ட்டில் நிலைமாறாத்தன்மையை அடையமுடியும்.

ஒற்றைஉள்ளீட்டாக்கமும் செயற்கூற்றுக்கலவையும்:

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

const f = a => b => c => d => a + b + c + d

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

console.log(f(1)(2)(3)(4)); // 10ஐ அச்சிடுகிறது.

இதனை இன்னும் எளிமையாக செய்வதற்கு பல திரட்டுகள் உள்ளன. அவற்றுள் Ramda-ஐப்பற்றி இப்பகுதியில் காணலாம்.

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

const f = R.curry((a, b, c, d) => a + b + c + d);
console.log(f(1, 2, 3, 4)); // 10ஐ அச்சிடுகிறது.
console.log(f(1, 2)(3, 4)); // மீண்டும் 10ஐ அச்சிடுகிறது.
console.log(f(1)(2)(3, 4)); // இப்போதும் 10ஐ மட்டுமே அச்சிடுகிறது.

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

const add = R.curry((x, y) => x + y);
const mult5 = value => value * 5;
const mult5AfterAdd10 = R.compose(mult5, add(10));

மேலும், ராம்டா பல உதவிச்செயற்கூறுகளையும் நமக்கு வழங்குகிறது. R.add, R.multiply ஆகியவற்றை பயன்படுத்தி மேற்கண்ட செயற்கூற்றை மாற்றியெழுதலாம்.

const mult5AfterAdd10 = R.compose(R.multiply(5), R.add(10));

செயற்கூறிய செயற்கூறுகள்:

map, filter, reduce ஆகிய செயற்கூறுகள் ராம்டாவினுள்ளே வரையறுக்கப்பட்டுள்ளன. ஜாவாஸ்கிரிப்ட்டின் Array.prototype-இல் இச்செயற்கூறுகள் இருப்பினும், ராம்டாவின் செயற்கூறுகள் ஒற்றைஉள்ளீட்டாக்கத்திற்கு ஏற்றதாக உள்ளன.

const isOdd = R.flip(R.modulo)(2);
const onlyOdd = R.filter(isOdd);
const isEven = R.complement(isOdd);
const onlyEven = R.filter(isEven);

R.modulo-இன் முதல் உள்ளீட்டுஉருபு வகுபடுமெண் (dividend), இரண்டாவது உள்ளீட்டுஉருபு வகுக்குமெண் (divisor). நமது எடுத்துக்காட்டில் R.flip என்பது அதற்கு கொடுக்கப்பட்ட செயற்கூற்றின் முதலிரண்டு உள்ளீட்டு உருபுகளின் வரிசையை மாற்றிவிடுகிறது.

எந்தவொரு எண்ணுக்கும் isOdd-இன் வெளியீடு பூச்சியம் அல்லது ஒன்றாக மட்டுமே இருக்கமுடியும். எனவே R.filter செயற்கூற்றுக்கு isOdd-ஐ அளிக்கும்போது, 0 என்ற மதிப்பு பொய்மையாகவும், 1 என்ற மதிப்பு உண்மையாகவும் எடுத்துக்கொள்ளப்படுகிறது.

R.complement- தனக்கு வழங்கப்பட்ட செயற்கூற்றின் எதிர்மறை செயற்கூற்றை வழங்குகிறது. இதனைப் பயன்படுத்தி, isEven செயற்கூற்றினைப் பெறுகிறோம்.

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

const numbers = [1, 2, 3, 4, 5, 6, 7, 8];
console.log(onlyEven(numbers)); // [2, 4, 6, 8]ஐ அச்சிடுகிறது.
console.log(onlyOdd(numbers)); // [1, 3, 5, 7]ஐ அச்சிடுகிறது.

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

முற்றும்

Leave a Reply

%d bloggers like this: