JavaScript Pipeline Operator: Functional Composition for Cleaner Code

JavaScript மேம்பாட்டின் எப்போதும் வளர்ந்து வரும் உலகில், சுத்தமான, பராமரிக்கக்கூடிய மற்றும் படிக்கக்கூடிய குறியீட்டை எழுதுவது மிக முக்கியமானது. இந்த இலக்கை அடைவதற்கு கணிசமாக உதவும் ஒரு கருவி ஜாவாஸ்கிரிப்ட் பைப்லைன் ஆபரேட்டர் (|>). இன்னும் ஒரு முன்மொழிவாக இருந்தாலும் (இந்த எழுதும் நேரத்தில் நிலை 1 இல் உள்ளது), பல டெவலப்பர்கள் Babel செருகுநிரல்கள் மூலம் அல்லது அது ஏற்கனவே ஆதரிக்கப்படும் சூழல்களில் இதைப் பயன்படுத்துகின்றனர், மேலும் குறியீடு தெளிவை மேம்படுத்தும் மற்றும் செயல்பாட்டு கலவையை ஒழுங்குபடுத்தும் திறனால் அதன் பயன்பாடு சீராக அதிகரித்து வருகிறது. இந்த கட்டுரை பைப்லைன் ஆபரேட்டர், அதன் நன்மைகள் மற்றும் நடைமுறை பயன்பாடுகளைப் பற்றிய விரிவான ஆய்வை வழங்குகிறது.

What is Functional Composition?

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

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

            const number = 5;
const squared = square(number);
const incremented = increment(squared);
console.log(incremented); // Output: 26

function square(x) {
  return x * x;
}

function increment(x) {
  return x + 1;
}
            

              
                Copy
              
            
          

செயல்பாட்டு கலவையுடன், நீங்கள் ஒரு கலவையான செயல்பாட்டை இதுபோல் வரையறுக்கலாம் (மேலும் நவீன அணுகுமுறைகளைப் பயன்படுத்தி):

            const compose = (...fns) => (x) => fns.reduceRight((v, f) => f(v), x);

const square = x => x * x;
const increment = x => x + 1;

const squareAndIncrement = compose(increment, square);

const number = 5;
const result = squareAndIncrement(number);
console.log(result); // Output: 26
            

              
                Copy
              
            
          

மேலே உள்ள 'compose' செயல்பாடு பயனுள்ளதாக இருந்தாலும், பைப்லைன் ஆபரேட்டர் இதை இன்னும் எளிதாக்குகிறது.

Introducing the JavaScript Pipeline Operator (|>)

ஜாவாஸ்கிரிப்டில் செயல்பாட்டு கலவையைச் செய்ய பைப்லைன் ஆபரேட்டர் (|>) மிகவும் படிக்கக்கூடிய மற்றும் உள்ளுணர்வு வழியை வழங்குகிறது. இது இடமிருந்து வலமாக செயல்பாட்டு அழைப்புகளை ஒன்றாக இணைக்க உங்களை அனுமதிக்கிறது, இது குறியீட்டு ஓட்டத்தை மிகவும் இயற்கையாக ஆக்குகிறது. அடிப்படையில், இது ஆபரேட்டரின் இடது பக்கத்தில் உள்ள மதிப்பை எடுத்து வலது பக்கத்தில் உள்ள செயல்பாட்டிற்கு வாதமாக அனுப்புகிறது.

பைப்லைன் ஆபரேட்டரைப் பயன்படுத்தி, முந்தைய எடுத்துக்காட்டு இதுபோல் இருக்கும் (பைப்லைன் ஆபரேட்டர் செருகுநிரல் நிறுவப்பட்ட Babel போன்ற டிரான்ஸ்பைலரைப் பயன்படுத்துகிறீர்கள் என்று வைத்துக்கொள்வோம்):

            function square(x) {
  return x * x;
}

function increment(x) {
  return x + 1;
}

const number = 5;
const result = number
  |> square
  |> increment;

console.log(result); // Output: 26
            

              
                Copy
              
            
          

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

Benefits of Using the Pipeline Operator

• Improved Readability: தொடர்ச்சியான செயல்பாடுகள் மூலம் தரவின் ஓட்டத்தை தெளிவாகக் காட்டுவதன் மூலம், பைப்லைன் ஆபரேட்டர் குறியீட்டைப் படிக்கவும் புரிந்து கொள்ளவும் எளிதாக்குகிறது. கூடுதலான செயல்பாட்டு அழைப்புகளுக்குப் பதிலாக, பைப்லைன் ஆபரேட்டர் படி-படி-படியாக மாற்றும் செயல்முறையை காட்சிப்படுத்துகிறது.
• Enhanced Maintainability: மட்டுத்தன்மையை மேம்படுத்துவதன் மூலமும், கவலைகளைப் பிரிப்பதன் மூலமும், பைப்லைன் ஆபரேட்டர் அதிக பராமரிக்கக்கூடிய குறியீட்டிற்கு பங்களிக்கிறது. பைப்லைனில் உள்ள ஒவ்வொரு செயல்பாடும் ஒரு குறிப்பிட்ட பணியைச் செய்கிறது, சிக்கல்களைக் கண்டறிந்து சரிசெய்வதை எளிதாக்குகிறது.
• Reduced Complexity: பைப்லைன் ஆபரேட்டர் பல மாற்றங்களை உள்ளடக்கிய குறியீட்டின் சிக்கலைக் கணிசமாகக் குறைக்கும். இது தற்காலிக மாறிகள் மற்றும் கூடுதலான செயல்பாட்டு அழைப்புகளின் தேவையை நீக்குகிறது, இதன் விளைவாக சுத்தமான மற்றும் சுருக்கமான குறியீடு கிடைக்கிறது.
• Increased Code Reusability: செயல்பாட்டு கலவை மீண்டும் பயன்படுத்தக்கூடிய செயல்பாடுகளை உருவாக்க ஊக்குவிக்கிறது. இந்த செயல்பாடுகளை பின்னர் பைப்லைன் ஆபரேட்டரைப் பயன்படுத்தி மிகவும் சிக்கலான செயல்பாடுகளை உருவாக்க எளிதாக இணைக்க முடியும்.

Practical Examples of the Pipeline Operator

பைப்லைன் ஆபரேட்டரின் பல்துறைத்திறனை நிரூபிக்கும் சில நடைமுறை எடுத்துக்காட்டுகளை ஆராய்வோம்.

Example 1: Data Transformation

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

1. பங்கு இல்லாத தயாரிப்புகளை வடிகட்டவும்.
2. மீதமுள்ள தயாரிப்புகளை அவற்றின் பெயர்களுக்கு மேப் செய்யவும்.
3. பெயர்களை அகர வரிசைப்படி வரிசைப்படுத்தவும்.
4. பெயர்களின் அணியை காற்புள்ளி பிரிக்கப்பட்ட சரமாக மாற்றவும்.

பைப்லைன் ஆபரேட்டர் இல்லாமல், குறியீடு இதுபோல் இருக்கலாம்:

            const products = [
  { name: 'Laptop', price: 1200, inStock: true },
  { name: 'Keyboard', price: 75, inStock: false },
  { name: 'Mouse', price: 25, inStock: true },
  { name: 'Monitor', price: 300, inStock: true },
];

const outOfStock = (product) => product.inStock === true;
const getName = (product) => product.name;

const processProducts = (products) => {
    const inStockProducts = products.filter(outOfStock);
    const productNames = inStockProducts.map(getName);
    const sortedNames = productNames.sort();
    const commaSeparated = sortedNames.join(', ');
    return commaSeparated;
};


const result = processProducts(products);
console.log(result); // Output: Laptop, Monitor, Mouse
            

              
                Copy
              
            
          

பைப்லைன் ஆபரேட்டரைப் பயன்படுத்தி, குறியீடு மிகவும் படிக்கக்கூடியதாகிறது:

            const products = [
  { name: 'Laptop', price: 1200, inStock: true },
  { name: 'Keyboard', price: 75, inStock: false },
  { name: 'Mouse', price: 25, inStock: true },
  { name: 'Monitor', price: 300, inStock: true },
];

const filterInStock = (products) => products.filter(product => product.inStock);
const mapToName = (products) => products.map(product => product.name);
const sortAlphabetically = (names) => [...names].sort(); // Create a copy to avoid modifying the original array
const joinWithComma = (names) => names.join(', ');

const result = products
  |> filterInStock
  |> mapToName
  |> sortAlphabetically
  |> joinWithComma;

console.log(result); // Output: Laptop, Monitor, Mouse
            

              
                Copy
              
            
          

இந்த பதிப்பு products அணிக்கு பயன்படுத்தப்படும் மாற்றங்களின் வரிசையை தெளிவாகக் காட்டுகிறது.

Example 2: Asynchronous Operations

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

            async function fetchData(url) {
  const response = await fetch(url);
  if (!response.ok) {
    throw new Error(`HTTP error! Status: ${response.status}`);
  }
  return await response.json();
}

function extractData(data) {
  //Process the Json into something more manageable
  return data.results;
}

function processData(results) {
  //Further processing of the results
  return results.map(result => result.name);
}

function displayData(processedData) {
  //Diplay the processed Data.
  return processedData;
}

async function main() {
  try {
    const url = 'https://api.example.com/data'; // Replace with a real API endpoint

    const result = await (url
      |> fetchData
      |> extractData
      |> processData
      |> displayData);

    console.log(result);
  } catch (error) {
    console.error('Error:', error);
  }
}

// main(); // Commenting this out as the url is a dummy value.

            

              
                Copy
              
            
          

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

Example 3: String Manipulation

ஒரு சரத்தில் பல செயல்பாடுகளைச் செய்ய வேண்டிய சூழ்நிலையை கவனியுங்கள்:

1. முன்னணி மற்றும் பின்தொடரும் இடைவெளியை அகற்றவும்.
2. சரமாக சிறிய எழுத்துக்கு மாற்றவும்.
3. பல இடைவெளிகளை ஒரு இடைவெளியாக மாற்றவும்.
4. ஒவ்வொரு சொல்லின் முதல் எழுத்தையும் பெரிய எழுத்தாக மாற்றவும்.

            function trim(str) {
  return str.trim();
}

function toLower(str) {
  return str.toLowerCase();
}

function removeMultipleSpaces(str) {
  return str.replace(/\s+/g, ' ');
}

function capitalizeWords(str) {
  return str.split(' ').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join(' ');
}

const inputString = '  Hello   World  ';

const result = inputString
  |> trim
  |> toLower
  |> removeMultipleSpaces
  |> capitalizeWords;

console.log(result); // Output: Hello World
            

              
                Copy
              
            
          

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

Considerations and Best Practices

• Function Purity: உங்கள் பைப்லைன்களில் தூய செயல்பாடுகளைப் பயன்படுத்த முயற்சிக்கவும். தூய செயல்பாடுகள் என்பது ஒரே உள்ளீட்டிற்கு எப்போதும் ஒரே வெளியீட்டை வழங்கும் மற்றும் பக்க விளைவுகள் இல்லாத செயல்பாடுகளாகும். இது உங்கள் குறியீட்டை மிகவும் கணிக்கக்கூடியதாகவும், சோதனை செய்ய எளிதாகவும் ஆக்குகிறது.
• Error Handling: உங்கள் பைப்லைனில் வலுவான பிழை கையாளுதலை செயல்படுத்தவும். சாத்தியமான பிழைகளை கருணையுடன் கையாள try...catch தொகுதிகள் அல்லது பிற பிழை கையாளுதல் வழிமுறைகளைப் பயன்படுத்தவும்.
• Function Naming: உங்கள் செயல்பாடுகளுக்கு விளக்கமான மற்றும் அர்த்தமுள்ள பெயர்களைத் தேர்ந்தெடுக்கவும். இது உங்கள் குறியீட்டைப் புரிந்துகொள்ளவும் பராமரிக்கவும் எளிதாக்கும்.
• Maintainability: உங்கள் திட்டம் முழுவதும் ஒரு நிலையான பாணியை கடைபிடிக்க முயற்சிக்கவும்.
• Composability: பைப்லைனிங் செய்யப்படும் செயல்பாடுகள் கலக்கக்கூடியதாக வடிவமைக்கப்பட்டுள்ளதா என்பதை உறுதிப்படுத்தவும். இது பொதுவாக அவை ஒரு வாதத்தை ஏற்றுக்கொண்டு, பைப்லைனில் உள்ள மற்றொரு செயல்பாட்டிற்கு உள்ளீடாகப் பயன்படுத்தக்கூடிய ஒரு மதிப்பைத் திருப்பித் தருகின்றன என்று பொருள்.

Adoption and Tooling

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

            npm install --save-dev @babel/plugin-proposal-pipeline-operator
            

              
                Copy
              
            
          

பின்னர் உங்கள் .babelrc அல்லது babel.config.js கோப்பில் செருகுநிரலைப் பயன்படுத்த Babel ஐ உள்ளமைக்கவும்:

            {
  "plugins": [["@babel/plugin-proposal-pipeline-operator", { "proposal": "minimal" }]]
}
            

              
                Copy
              
            
          

குறைந்தபட்ச முன்மொழிவு அதன் எளிமை காரணமாக அடிக்கடி விரும்பப்படுகிறது. மற்ற முன்மொழிவுகள் உள்ளன (எ.கா., "fsharp") ஆனால் அவை மிகவும் சிக்கலானவை.

Alternatives to the Pipeline Operator

பைப்லைன் ஆபரேட்டருக்கு முன், டெவலப்பர்கள் பெரும்பாலும் செயல்பாட்டு கலவையை அடைய மற்ற நுட்பங்களைப் பயன்படுத்தினர். சில பொதுவான மாற்றுகள் பின்வருமாறு:

• Nested Function Calls: இது மிகவும் அடிப்படை அணுகுமுறை, ஆனால் குறிப்பாக சிக்கலான கலவைகளுடன் படிக்கவும் புரிந்து கொள்ளவும் கடினமாகிவிடும்.
• Helper Functions (Compose/Pipe): Lodash மற்றும் Ramda போன்ற நூலகங்கள் கலவையான செயல்பாடுகளை உருவாக்க உங்களை அனுமதிக்கும் compose மற்றும் pipe செயல்பாடுகளை வழங்குகின்றன.
• Method Chaining: Moment.js போன்ற சில நூலகங்கள், பொருள்கள் மீதான செயல்பாடுகளைச் செய்வதற்கு ஒரு சரளமான இடைமுகத்தை வழங்க முறை சங்கிலியைப் பயன்படுத்துகின்றன. இருப்பினும், இந்த அணுகுமுறை சங்கிலிக்கு வடிவமைக்கப்பட்ட முறைகளைக் கொண்ட பொருள்களுக்கு மட்டுமே.

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

Conclusion

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

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