करीइंग कार्यात्मक प्रोग्रामिंग में एक शक्तिशाली अवधारणा है जो एक फ़ंक्शन को एकाधिक तर्कों के साथ कार्यों के अनुक्रम में बदल देती है, प्रत्येक एक एकल तर्क लेता है। यह तकनीक अधिक मॉड्यूलर और पुन: प्रयोज्य कोड की अनुमति देती है। जावास्क्रिप्ट में, करीइंग को विभिन्न तरीकों से लागू किया जा सकता है। यह ब्लॉग करीइंग का पता लगाएगा, उदाहरण प्रदान करेगा, और एन तर्क करींग प्राप्त करने के लिए विभिन्न तरीकों पर चर्चा करेगा।

करीइंग क्या है?

Currying एक फ़ंक्शन को परिवर्तित करने की प्रक्रिया है जो कई तर्कों को कार्यों की एक श्रृंखला में ले जाती है जिनमें से प्रत्येक एक ही तर्क लेता है। उदाहरण के लिए, एक फ़ंक्शन f(a, b, c) को f(a)(b)(c) में बदला जा सकता है।

करीइंग का उपयोग क्यों करें?

• आंशिक अनुप्रयोग: करीइंग आपको किसी फ़ंक्शन के कुछ तर्कों को ठीक करने और एक नया फ़ंक्शन बनाने की अनुमति देता है।
• उच्च-क्रम फ़ंक्शंस: यह उच्च-ऑर्डर फ़ंक्शंस के उपयोग की सुविधा प्रदान करता है, जो अन्य फ़ंक्शंस को तर्क के रूप में लेते हैं या उन्हें वापस करते हैं।
• कोड पुन: प्रयोज्य: किए गए फ़ंक्शन अधिक पुन: प्रयोज्य और संयोजन योग्य हैं।
• कार्यात्मक संरचना: करींग बेहतर कार्यात्मक संरचना को सक्षम बनाता है, जहां जटिल कार्यों को सरल कार्यों के संयोजन से बनाया जाता है, जिससे क्लीनर और अधिक रखरखाव योग्य कोड प्राप्त होता है।

सरल करी बनाने का उदाहरण

करी कैसे काम करती है यह समझने के लिए आइए एक बुनियादी उदाहरण से शुरुआत करें।

असंक्रमित कार्य

यहां एक सरल फ़ंक्शन है जो तीन संख्याएं जोड़ता है:

function add(a, b, c) {
  return a   b   c;
}

console.log(add(1, 2, 3)); // Output: 6

स्पष्टीकरण: यह फ़ंक्शन ऐड तीन तर्क ए, बी और सी लेता है, और उनका योग लौटाता है। जब हम add(1, 2, 3) कहते हैं, तो यह 6 लौटाता है।

करी समारोह

अब, आइए इस फ़ंक्शन को एक त्वरित संस्करण में परिवर्तित करें:

function curryAdd(a) {
  return function(b) {
    return function(c) {
      return a   b   c;
    };
  };
}

console.log(curryAdd(1)(2)(3)); // Output: 6

स्पष्टीकरण: curryAdd फ़ंक्शन एक तर्क a लेता है और एक फ़ंक्शन लौटाता है जो एक तर्क b लेता है, जो बदले में एक फ़ंक्शन लौटाता है जो एक तर्क c लेता है। अंतिम फ़ंक्शन ए, बी और सी का योग लौटाता है। जब हम curryAdd(1)(2)(3) को कॉल करते हैं, तो यह क्रमिक रूप से नेस्टेड फ़ंक्शंस के माध्यम से तर्क 1, 2 और 3 को पास करता है, जिसके परिणामस्वरूप 6 होता है।

एरो फ़ंक्शंस के साथ करींग

जावास्क्रिप्ट के एरो फ़ंक्शन त्वरित फ़ंक्शन बनाने का एक संक्षिप्त तरीका प्रदान करते हैं।

const curryAddArrow = a => b => c => a   b   c;

console.log(curryAddArrow(1)(2)(3)); // Output: 6

स्पष्टीकरण: curryAddArrow फ़ंक्शन एक एरो फ़ंक्शन है जो एक तर्क लेता है और एक अन्य एरो फ़ंक्शन लौटाता है जो b लेता है, जो एक और एरो फ़ंक्शन लौटाता है जो c लेता है। अंतिम तीर फ़ंक्शन ए, बी और सी का योग लौटाता है। जब हम curryAddArrow(1)(2)(3) को कॉल करते हैं, तो यह क्रमिक रूप से नेस्टेड एरो फ़ंक्शन के माध्यम से तर्क 1, 2 और 3 को पास करता है, जिसके परिणामस्वरूप 6 होता है।

उदाहरण

1.कॉन्फ़िगरेशन फ़ंक्शंस

करींग के लिए एक सामान्य उपयोग का मामला कॉन्फ़िगरेशन फ़ंक्शन है। उदाहरण के लिए, कल्पना करें कि आप एक लॉगिंग उपयोगिता बना रहे हैं जहां आप लॉगिंग स्तर और संदेश प्रारूप को अलग से कॉन्फ़िगर करना चाहते हैं।

function logger(level) {
  return function (message) {
    console.log(`[${level}] ${message}`);
  };
}

const infoLogger = logger('INFO');
const errorLogger = logger('ERROR');

infoLogger('This is an info message');
errorLogger('This is an error message');

2. स्ट्रिंग फ़ॉर्मेटर

आइए एक व्यावहारिक उदाहरण पर विचार करें जहां एक स्ट्रिंग फ़ॉर्मेटर बनाने के लिए करीइंग का उपयोग किया जा सकता है। यह फ़ॉर्मेटर आपको उपसर्ग और प्रत्यय को अलग-अलग कॉन्फ़िगर करने की अनुमति देगा।

function formatter(prefix) {
  return function (suffix) {
    return function (str) {
      return `${prefix}${str}${suffix}`;
    };
  };
}

const htmlFormatter = formatter('')('');
console.log(htmlFormatter('Hello')); // Hello

const parensFormatter = formatter('(')(')');
console.log(parensFormatter('123')); // (123)

आधुनिक जावास्क्रिप्ट पुस्तकालयों में करींग

करीइंग का उपयोग आमतौर पर लोदाश और रामदा जैसी आधुनिक जावास्क्रिप्ट लाइब्रेरी में किया जाता है। उदाहरण के लिए, लॉडैश में, आप आसानी से तैयार किए गए फ़ंक्शन बनाने के लिए _.curry विधि का उपयोग कर सकते हैं।

const _ = require('lodash');

function multiply(a, b, c) {
  return a * b * c;
}

const curriedMultiply = _.curry(multiply);

console.log(curriedMultiply(2)(3)(4)); // 24
console.log(curriedMultiply(2, 3)(4)); // 24

एन तर्कों के साथ करींग

आइए एक पुनरावर्ती फ़ंक्शन के साथ करी करने का उदाहरण देखें जो n तर्क जोड़ता है। हम एक फ़ंक्शन बनाने के लिए करीइंग का उपयोग करेंगे जो एक समय में किसी भी संख्या में तर्क स्वीकार कर सकता है, और उन्हें एक साथ जोड़ सकता है।

function curryAddition(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    } else {
      return function(...nextArgs) {
        return curried(...args, ...nextArgs);
      };
    }
  };
}

// This function sums an array of numbers
function add(...nums) {
  return nums.reduce((acc, num) => acc   num, 0);
}

// Creating a curried version of the addition function
const curriedAdd = curryAddition(add);

// Function to handle n arguments
function curriedAddN(...initialArgs) {
  function adder(...args) {
    if (args.length === 0) {
      return curriedAdd(...initialArgs);
    }
    initialArgs.push(...args);
    return adder;
  }
  return adder;
}

// Examples
const addFiveNumbers = curriedAddN();
console.log(addFiveNumbers(1)(2)(3)(4)(5)()); // 15

const addThreeNumbers = curriedAddN(1)(2)(3);
console.log(addThreeNumbers()); // 6

const addNumbersInSteps = curriedAddN(1, 2)(3)(4, 5);
console.log(addNumbersInSteps()); // 15

निष्कर्ष

कार्यात्मक प्रोग्रामिंग में करीइंग एक शक्तिशाली तकनीक है जो कोड की मॉड्यूलैरिटी और पुन: प्रयोज्यता को बढ़ाती है। फ़ंक्शंस को एकल-तर्क फ़ंक्शंस की श्रृंखलाओं में परिवर्तित करके, करीइंग आंशिक अनुप्रयोग और लचीली फ़ंक्शन संरचना की अनुमति देता है। चाहे कॉन्फ़िगरेशन, स्ट्रिंग फ़ॉर्मेटिंग, या जटिल गणनाओं के लिए, करीइंग आपके कोड को अधिक अभिव्यंजक और अनुकूलनीय बना सकती है।