ES6 இல் Arrow செயல்பாடுகள்

Arrow செயல்பாடுகள் ES6 இல் (ECMAScript 2015) அறிமுகப்படுத்தப்பட்ட ஜாவாஸ்கிரிப்டில் அநாமதேய (anonymous) செயல்பாடுகளை எழுதுவதற்கான ஒரு சுருக்கமான வழியாகும். அவை செயல்பாடுகளை வரையறுக்க மிகவும் கச்சிதமான மற்றும் படிக்கக்கூடிய தொடரியலை வழங்குகின்றன, குறிப்பாக நீங்கள் எளிய, ஒற்றை வெளிப்பாடு செயல்பாடுகளைக் கொண்டிருக்கும்போது. Arrow செயல்பாடுகள் நவீன ஜாவாஸ்கிரிப்டின் ஒரு அடிப்படை அம்சமாகும், மேலும் அவை பாரம்பரிய செயல்பாட்டு வெளிப்பாடுகளை (traditional function expressions) விட பல நன்மைகளை வழங்குகின்றன.

தொடரியல் (Syntax):

Arrow செயல்பாடுகளுக்கான தொடரியல் நேராகவும் எளிமையாகவும் இருக்கும்:

const functionName = (parameters) => expression;

• const functionName: இங்குதான் நீங்கள் ஒரு மாறிக்கு செயல்பாட்டை ஒதுக்குகிறீர்கள். அநாமதேய செயல்பாடுகளுக்கு செயல்பாட்டின் பெயரைத் தவிர்க்கலாம்.

• (parameters): இவை செயல்பாடு ஏற்கும் உள்ளீட்டு அளவுருக்கள் (வாதங்கள்). ஒரே ஒரு அளவுரு மட்டுமே இருந்தால், அடைப்புக்குறிகளைத் தவிர்க்கலாம்.

• =>: => என்ற குறியீடு நீங்கள் ஒரு arrow செயல்பாட்டை வரையறுக்கிறீர்கள் என்பதைக் குறிக்கிறது.

• expression: இது செயல்பாடு திரும்பப் பெறும் (returns) மதிப்பு. செயல்பாடு ஒற்றை அறிக்கையைக் கொண்டிருந்தால், சுருள் அடைப்புக்குறிகள் மற்றும் return முக்கிய சொல்லைத் தவிர்க்கலாம்.

எடுத்துக்காட்டுகள்:

Arrow செயல்பாடுகளின் தொடரியலை விளக்குவதற்கு சில எடுத்துக்காட்டுகள் இங்கே:

1. அளவுருக்கள் இல்லாத எளிய arrow செயல்பாடு:

const sayHello = () => "Hello, World!";

1. ஒரு அளவுருவைக் கொண்ட arrow செயல்பாடு:

const double = (x) => x * 2;

1. பல அளவுருக்களைக் கொண்ட arrow செயல்பாடு:

const add = (a, b) => a + b;

பயன்பாட்டு வழக்குகள் (Use Cases):

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

1. குறுகிய, அநாமதேய செயல்பாடுகள்: Arrow செயல்பாடுகள் குறுகிய, ஒரு-வரி செயல்பாடுகளுக்கு சரியானவை. அவை ஒரு முழு செயல்பாட்டு வெளிப்பாட்டை (function expression) எழுதுவதற்கான தேவையைக் குறைக்கின்றன.

2. வரிசைகளை மீள்திருப்புதல் (Iterating Arrays): வரிசைகளின் மீதான மீள்திருப்பை (iteration) எளிமையாக்க map, filter மற்றும் reduce போன்ற array முறைகளுடன் Arrow செயல்பாடுகள் நன்றாகச் செயல்படுகின்றன.

const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map((x) => x * 2);

1. Callback செயல்பாடுகள்: அவை பெரும்பாலும் setTimeout மற்றும் fetch போன்ற ஒத்திசைவற்ற (asynchronous) செயல்பாடுகளுக்கு callback செயல்பாடுகளாகப் பயன்படுத்தப்படுகின்றன.

setTimeout(() => {
  console.log("Timer முடிந்தது");
}, 1000);

1. this சூழலை (Context) பிணைத்தல்: Arrow செயல்பாடுகள் தங்களைக் கொண்டிருக்கும் செயல்பாட்டிலிருந்து this சூழலைப் பெறுகின்றன, இதனால் this மாறுவதைப் பற்றி கவலைப்படாமல் பொருள்களில் உள்ள முறைகளை (methods) வரையறுக்க அவை பயனுள்ளதாக இருக்கும்.

const person = {
  name: "John",
  greet: function() {
    setTimeout(() => {
      console.log(`வணக்கம், என் பெயர் ${this.name}`);
    }, 1000);
  },
};

person.greet();

Arrow செயல்பாடுகள் ஒவ்வொரு சூழ்நிலைக்கும் ஏற்றவை அல்ல என்பதைக் கவனத்தில் கொள்வது அவசியம். அவற்றுக்குச் சொந்தமான this சூழல் இல்லை, அவற்றை constructors ஆகப் பயன்படுத்த முடியாது, மேலும் மிகவும் சிக்கலான, பல வரி அமைப்பைக் கொண்ட செயல்பாடுகளுக்கு அவை பொருத்தமானதாக இருக்காது. இதுபோன்ற சந்தர்ப்பங்களுக்கு, பாரம்பரிய செயல்பாட்டு வெளிப்பாடுகளே (traditional function expressions) இன்னும் விருப்பமான தேர்வாக உள்ளன. எளிய, சுருக்கமான மற்றும் ஒரு வரி செயல்பாடுகளுக்குப் பயன்படுத்தப்படும்போது Arrow செயல்பாடுகள் மிகவும் பயனுள்ளதாக இருக்கும்.