जावास्क्रिप्ट करी कार्य

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

कार्यात्मक प्रोग्रामिंग सिद्धांत कई भाषाओं द्वारा समर्थित हैं। इनमें जावास्क्रिप्ट, हास्केल, क्लोजर, एर्लांग शामिल हैं। कार्यात्मक प्रोग्रामिंग तंत्रों का उपयोग दूसरों के बीच, शुद्ध कार्यों, करी कार्यों, उच्च-क्रम कार्यों जैसी अवधारणाओं के बीच ज्ञान का अर्थ है।



आज हम जिस सामग्री का अनुवाद कर रहे हैं, वह करी के बारे में है। हम इस बारे में बात करेंगे कि कैसे कार्य करना और कैसे इस तंत्र का ज्ञान JS डेवलपर के लिए उपयोगी हो सकता है।

करी क्या है?

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

करीने की बात करते हुए, हम यह कह सकते हैं कि यह एक फ़ंक्शन को कई तर्कों के साथ एक फ़ंक्शन में परिवर्तित करने की प्रक्रिया है, जिसमें कम अशुद्धता है।

Arity एक फ़ंक्शन के लिए तर्कों की संख्या है। उदाहरण के लिए, यहाँ एक जोड़ी की घोषणा है:

function fn(a, b) {    //... } function _fn(a, b, c) {    //... } 

_fn फ़ंक्शन दो तर्क लेता है (यह एक बाइनरी या 2-एरी फ़ंक्शन है), _fn फ़ंक्शन तीन तर्क (एक टर्नरी, 3-आर्य फ़ंक्शन) लेता है।

चलिए उस स्थिति के बारे में बात करते हैं जब, करीने के दौरान, कई तर्कों के साथ एक फ़ंक्शन को फ़ंक्शन के एक सेट में बदल दिया जाता है, जिनमें से प्रत्येक एक तर्क लेता है।

एक उदाहरण पर विचार करें। हमारे पास निम्नलिखित कार्य हैं:

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

यह तीन तर्क लेता है और उनके उत्पाद को लौटाता है:

 multiply(1,2,3); // 6 

अब आइए विचार करें कि इसे कार्यों के एक सेट में कैसे परिवर्तित किया जाए, जिनमें से प्रत्येक एक तर्क लेता है। आइए इस फ़ंक्शन का एक घुमावदार संस्करण बनाएं और देखें कि कई कार्यों को कॉल करते समय समान परिणाम कैसे प्राप्त करें:

 function multiply(a) {   return (b) => {       return (c) => {           return a * b * c       }   } } log(multiply(1)(2)(3)) // 6 

जैसा कि आप देख सकते हैं, यहाँ हमने कॉल को तीन तर्कों - सिंगल multiply(1,2,3) से तीन फ़ंक्शन के लिए एक कॉल में बदल दिया - multiply(1)(2)(3) ।

यह पता चला है कि एक फ़ंक्शन कई कार्यों में बदल गया है। नए निर्माण का उपयोग करते समय, पिछले एक को छोड़कर, गणना के परिणाम को वापस करने वाला प्रत्येक फ़ंक्शन, एक तर्क लेता है और दूसरा फ़ंक्शन देता है, एक तर्क को स्वीकार करने और किसी अन्य फ़ंक्शन को वापस करने में भी सक्षम होता है। यदि फॉर्म का एक निर्माण कई multiply(1)(2)(3) आपको बहुत स्पष्ट नहीं लगता है, तो आइए इसे इस रूप में लिखें कि इसे बेहतर तरीके से समझ सकें:

 const mul1 = multiply(1); const mul2 = mul1(2); const result = mul2(3); log(result); // 6 

अब यहाँ क्या हो रहा है लाइन से लाइन।

सबसे पहले, हम तर्क 1 को multiply फ़ंक्शन में पास करते हैं:

 const mul1 = multiply(1); 

जब यह फ़ंक्शन काम करता है, तो यह डिज़ाइन काम करता है:

 return (b) => {       return (c) => {           return a * b * c       }   } 

अब mul1 में एक फ़ंक्शन का संदर्भ है जो एक तर्क b लेता है। हम फ़ंक्शन mul1 कॉल करते हैं, इसे 2 पास करते हैं:

 const mul2 = mul1(2); 

इस कॉल के परिणामस्वरूप, निम्नलिखित कोड निष्पादित किया जाएगा:

 return (c) => {           return a * b * c       } 

mul2 एक फ़ंक्शन का संदर्भ होगा जो इसमें हो सकता है, उदाहरण के लिए, निम्न ऑपरेशन के परिणामस्वरूप:

 mul2 = (c) => {           return a * b * c       } 

यदि हम अब फ़ंक्शन mul2 कॉल करते हैं, तो इसे 3 पास करते हैं, तो फ़ंक्शन तर्कों और b का उपयोग करके आवश्यक गणना करेगा।

 const result = mul2(3); 

इन गणनाओं का परिणाम 6 होगा:

 log(result); // 6 

mul2 फ़ंक्शन, जिसमें नेस्टिंग का उच्चतम स्तर है, गुंजाइश तक पहुंच है, multiply और mul1 द्वारा गठित क्लोजर तक। यही कारण है कि mul2 फ़ंक्शन में mul2 फ़ंक्शन में घोषित चर के साथ गणना करना संभव है, जिनका निष्पादन पहले ही पूरा हो चुका है, जो पहले से ही कुछ मानों को वापस कर चुके हैं और कचरा कलेक्टर द्वारा संसाधित किए जाते हैं।

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

 function volume(l,w,h) {   return l * w * h; } const vol = volume(100,20,90) // 180000 

यहाँ इसका करी संस्करण क्या दिखता है:

 function volume(l) {   return (w) => {       return (h) => {           return l * w * h       }   } } const vol = volume(100)(20)(90) // 180000 

तो, करी निम्नलिखित विचार पर आधारित है: एक निश्चित फ़ंक्शन के आधार पर, एक अन्य फ़ंक्शन बनाया जाता है जो एक विशेष फ़ंक्शन देता है।

करी और कार्यों का आंशिक उपयोग

अब, शायद, एक भावना है कि नेस्टेड फ़ंक्शन की संख्या के रूप में फ़ंक्शन का प्रतिनिधित्व करते समय, नेस्टेड फ़ंक्शन की संख्या, फ़ंक्शन के तर्कों की संख्या पर निर्भर करती है। और अगर करीने की बात आती है, तो वह है।

वॉल्यूम की गणना करने के लिए फ़ंक्शन का एक विशेष संस्करण, जिसे हमने पहले ही देखा है, इसे निम्नानुसार बनाया जा सकता है:

 function volume(l) {   return (w, h) => {       return l * w * h   } } 

यहां विचार लागू किए जाते हैं, ऊपर चर्चा किए गए लोगों के समान। आप इस फ़ंक्शन का उपयोग इस प्रकार कर सकते हैं:

 const hV = volume(70); hV(203,142); hV(220,122); hV(120,123); 

और आप यह कर सकते हैं:

 volume(70)(90,30); volume(70)(390,320); volume(70)(940,340); 

वास्तव में, यहां आप देख सकते हैं कि कैसे हम volume(70) कमांड के साथ, निकायों की मात्रा की गणना के लिए एक विशेष फ़ंक्शन बनाया, जिसमें से एक आयाम (अर्थात्, लंबाई, l ) तय किया गया है। volume फ़ंक्शन 3 तर्कों की अपेक्षा करता है और इसमें 2 नेस्टेड फ़ंक्शन होते हैं, समान फ़ंक्शन के पिछले संस्करण के विपरीत, जिस करी संस्करण में 3 नेस्टेड फ़ंक्शन होते हैं।

volume(70) कॉल करने के बाद प्राप्त फ़ंक्शन आंशिक फ़ंक्शन एप्लिकेशन की अवधारणा को लागू करता है। फ़ंक्शंस की करी और आंशिक अनुप्रयोग एक-दूसरे के समान हैं, लेकिन अवधारणाएं अलग हैं।

आंशिक अनुप्रयोग में, फ़ंक्शन कम तर्कों (कम arity) के साथ दूसरे फ़ंक्शन में बदल जाता है। ऐसे फ़ंक्शन के कुछ तर्क तय किए गए हैं (डिफ़ॉल्ट मान उनके लिए निर्धारित हैं)।

उदाहरण के लिए, इस तरह के एक समारोह है:

 function acidityRatio(x, y, z) {   return performOp(x,y,z) } 

इसे इस में बदला जा सकता है:

 function acidityRatio(x) {   return (y,z) => {       return performOp(x,y,z)   } } 

performOp() फ़ंक्शन का कार्यान्वयन यहां नहीं दिया गया है, क्योंकि यह विचार के तहत अवधारणाओं को प्रभावित नहीं करता है।

फ़ंक्शन जिसे नए acidityRatio() फ़ंक्शन को एक तर्क के साथ प्राप्त किया जा सकता है, जिसका मान निश्चित करने की आवश्यकता है, मूल फ़ंक्शन है, जिसमें से एक तर्क निश्चित है, और यह फ़ंक्शन मूल से कम एक तर्क लेता है।

फ़ंक्शन का करी संस्करण इस तरह दिखेगा:

 function acidityRatio(x) {   return (y) = > {       return (z) = > {           return performOp(x,y,z)       }   } } 

जैसा कि आप देख सकते हैं, करी करते समय, नेस्टेड फ़ंक्शन की संख्या मूल फ़ंक्शन के तर्कों की संख्या के बराबर होती है। इनमें से प्रत्येक कार्य अपने स्वयं के तर्क की अपेक्षा करता है। यह स्पष्ट है कि यदि तर्कों के कार्य को स्वीकार नहीं किया जाता है, या केवल एक तर्क को स्वीकार करता है, तो इस पर अंकुश नहीं लगाया जा सकता है।

ऐसी स्थिति में जहां एक फ़ंक्शन के दो तर्क होते हैं, इसके करी और आंशिक अनुप्रयोग के परिणाम को संयोग कहा जा सकता है। उदाहरण के लिए, हमारे पास एक ऐसा कार्य है:

 function div(x,y) {   return x/y; } 

मान लें कि हमें इसे फिर से लिखने की ज़रूरत है ताकि हम पहले तर्क को ठीक कर सकें, एक फ़ंक्शन प्राप्त करें जो गणना करता है, जब यह केवल दूसरा तर्क पास करता है, अर्थात हमें इस फ़ंक्शन को आंशिक रूप से लागू करने की आवश्यकता है। यह इस तरह दिखेगा:

 function div(x) {   return (y) => {       return x/y;   } } 

इसके करीने का परिणाम बिल्कुल वैसा ही दिखेगा।

करी और कार्यों के आंशिक अनुप्रयोग की अवधारणाओं के व्यावहारिक अनुप्रयोग पर

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

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

 function discount(price, discount) {   return price * discount } 

ग्राहकों की एक निश्चित श्रेणी है, चलो उन्हें "प्रिय ग्राहक" कहते हैं, जिन्हें हम 10% छूट देते हैं। उदाहरण के लिए, यदि ऐसा ग्राहक $ 500 के लिए कुछ खरीदता है, तो हम उसे $ 50 की छूट देते हैं:

 const price = discount(500,0.10); // $50 // $500 - $50 = $450 

यह देखना आसान है कि इस दृष्टिकोण के साथ, हमें लगातार इस फ़ंक्शन को दो तर्कों के साथ कॉल करना होगा:

 const price = discount(1500,0.10); // $150 // $1,500 - $150 = $1,350 const price = discount(2000,0.10); // $200 // $2,000 - $200 = $1,800 const price = discount(50,0.10); // $5 // $50 - $5 = $45 const price = discount(5000,0.10); // $500 // $5,000 - $500 = $4,500 const price = discount(300,0.10); // $30 // $300 - $30 = $270 

मूल फ़ंक्शन को एक ऐसे रूप में घटाया जा सकता है जो आपको पूर्व निर्धारित छूट स्तर के साथ नए कार्यों को प्राप्त करने की अनुमति देगा, यह कॉल करने पर कि यह खरीद राशि को स्थानांतरित करने के लिए पर्याप्त है। हमारे उदाहरण में discount() फ़ंक्शन के दो तर्क हैं। यहाँ पर यह दिखता है कि हम इसे किस रूप में बदलते हैं:

 function discount(discount) {   return (price) => {       return price * discount;   } } const tenPercentDiscount = discount(0.1); 

tenPercentDiscount() फ़ंक्शन discount() फ़ंक्शन के आंशिक अनुप्रयोग का परिणाम है। जब इस फ़ंक्शन के tenPercentDiscount() कॉल किया जाता है, तो यह मूल्य पारित करने के लिए पर्याप्त है, और 10% की discount , यानी, discount तर्क, पहले से ही सेट किया जाएगा:

 tenPercentDiscount(500); // $50 // $500 - $50 = $450 

यदि हमारे स्टोर में खरीदार हैं जिन्होंने 20% की छूट देने का फैसला किया है, तो आप उनके साथ काम करने के लिए उपयुक्त फ़ंक्शन प्राप्त कर सकते हैं:

 const twentyPercentDiscount = discount(0.2); 

अब 20% छूट को ध्यान में रखते हुए, सामान की लागत की गणना करने के लिए twentyPercentDiscount() फ़ंक्शन को कहा जा सकता है:

 twentyPercentDiscount(500); // 100 // $500 - $100 = $400 twentyPercentDiscount(5000); // 1000 // $5,000 - $1,000 = $4,000 twentyPercentDiscount(1000000); // 200000 // $1,000,000 - $200,000 = $600,000 

अन्य कार्यों के आंशिक अनुप्रयोग के लिए सार्वभौमिक कार्य

हम एक फ़ंक्शन विकसित करेंगे जो किसी भी फ़ंक्शन को स्वीकार करता है और इसके संस्करण को लौटाता है, जो कि एक फ़ंक्शन है, जिनमें से कुछ तर्क पहले से सेट हैं। यहां वह कोड है जो आपको ऐसा करने की अनुमति देता है (आप, यदि आप एक समान फ़ंक्शन विकसित करने के लिए सेट हैं, तो यह काफी संभव है कि आपको परिणामस्वरूप कुछ और मिलेगा):

 function partial(fn, ...args) {   return (..._arg) => {       return fn(...args, ..._arg);   } } 

partial() फ़ंक्शन fn फ़ंक्शन को स्वीकार करता है, जिसे हम आंशिक रूप से लागू फ़ंक्शन में बदलना चाहते हैं, और मापदंडों की एक चर संख्या (...args )। rest विवरण का उपयोग fn बाद सभी मापदंडों को fn में लाने के लिए किया जाता है।

यह फ़ंक्शन एक और फ़ंक्शन देता है जो मापदंडों की एक चर संख्या ( _arg ) को भी स्वीकार करता है। यह फ़ंक्शन, बदले में, मूल fn फ़ंक्शन को कॉल करता है, इसे पैरामीटर पास करता है ...args और ..._arg ( spread ऑपरेटर का उपयोग करके)। फ़ंक्शन गणना करता है और परिणाम देता है।

आयताकार समानांतर चतुर्भुज की मात्रा की गणना करने के लिए डिज़ाइन किए गए volume फ़ंक्शन का एक प्रकार बनाने के लिए हम इस फ़ंक्शन का उपयोग करते हैं, जिसका एक पक्ष तय हो गया है:

 function volume(l,h,w) {   return l * h * w } const hV = partial(volume,100); hV(200,900); // 18000000 hV(70,60); // 420000 

यहां आप अन्य कार्यों को करने के लिए एक सार्वभौमिक कार्य का एक उदाहरण पा सकते हैं।

परिणाम

इस लेख में, हमने करी और कार्यों के आंशिक अनुप्रयोग के बारे में बात की। फ़ंक्शन को बदलने के लिए ये तरीके जावास्क्रिप्ट में बंद होने के कारण कार्यान्वित किए जाते हैं और इस तथ्य के कारण कि जेएस में फ़ंक्शन प्रथम श्रेणी की वस्तुएं हैं (उन्हें अन्य कार्यों के लिए तर्क के रूप में पारित किया जा सकता है, उनमें से लौटाया गया, चर को सौंपा गया)।

प्रिय पाठकों! क्या आप अपनी परियोजनाओं में करी तकनीकों और कार्यों के आंशिक अनुप्रयोग का उपयोग करते हैं?