आंशिक अनुप्रयोग
Function के तर्क पहले से भरें।
आंशिक अनुप्रयोग, CoddyKit पर Lua Academy का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह Lua Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Lua Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
आंशिक अनुप्रयोग क्या है
आंशिक अनुप्रयोग का अर्थ है किसी फ़ंक्शन के कुछ तर्क अभी तय कर देना और बाकी बाद में देना। इससे एक नया फ़ंक्शन मिलता है, जिसे कम तर्कों की आवश्यकता होती है।
इससे आप पहले से ज्ञात मानों को स्थिर करके किसी सामान्य फ़ंक्शन को विशेष फ़ंक्शन में बदल सकते हैं।
हाथ से किया गया उदाहरण
मान लीजिए आपके पास एक add फ़ंक्शन है। आप 5 को अपने साथ रखने वाला क्लोज़र लिखकर addFive बना सकते हैं, जो दूसरी संख्या की प्रतीक्षा करता है।
अपने साथ रखा गया मान लौटाए गए फ़ंक्शन में रहता है, इसलिए हर कॉल में केवल बचे हुए तर्क की आवश्यकता होती है।
local function add(a, b)
return a + b
end
local function addFive(b)
return add(5, b)
end
print(addFive(10))
print(addFive(2))पहला तर्क बाँधना
हम इस तरीके को सामान्य बना सकते हैं। bind1 सहायक एक फ़ंक्शन और एक स्थिर पहला तर्क लेता है और दूसरा तर्क पाने वाला नया फ़ंक्शन लौटाता है।
क्लोज़र f और स्थिर किए गए मान दोनों को अपने साथ रखता है, फिर बुलाए जाने पर सब कुछ आगे भेज देता है।
local function bind1(f, a)
return function(b)
return f(a, b)
end
end
local function mul(x, y) return x * y end
local double = bind1(mul, 2)
print(double(7))
print(double(50))परिवर्ती तर्कों का उपयोग
किसी भी संख्या में शुरुआती तर्कों को स्थिर करने के लिए Lua के परिवर्ती-तर्क वाक्य-विन्यास ... का उपयोग करें। आप स्थिर तर्कों को अपने साथ रखते हैं और कॉल के समय बाद वाले तर्क जोड़ते हैं।
तर्क-सूचियों को रखने और फैलाने में table.pack और table.unpack फ़ंक्शन सहायता करते हैं।
local function partial(f, ...)
local fixed = table.pack(...)
return function(...)
local rest = table.pack(...)
local args = {}
for i = 1, fixed.n do args[i] = fixed[i] end
for i = 1, rest.n do args[fixed.n + i] = rest[i] end
return f(table.unpack(args, 1, fixed.n + rest.n))
end
end
local function add3(a, b, c) return a + b + c end
local add10 = partial(add3, 10)
print(add10(2, 3))कई आर्ग्युमेंट तय करना
क्योंकि partial परिवर्ती संख्या वाले आर्ग्युमेंट स्वीकार करता है, इसलिए आप एक ही बार में एक से अधिक आर्ग्युमेंट तय कर सकते हैं। इसके बाद लौटाए गए फ़ंक्शन को केवल बाकी आर्ग्युमेंट की आवश्यकता होती है।
यहाँ तीन में से दो आर्ग्युमेंट पहले से भरे गए हैं, इसलिए एक-आर्ग्युमेंट वाला फ़ंक्शन बचता है।
local function partial(f, ...)
local fixed = table.pack(...)
return function(...)
local rest = table.pack(...)
local args = {}
for i = 1, fixed.n do args[i] = fixed[i] end
for i = 1, rest.n do args[fixed.n + i] = rest[i] end
return f(table.unpack(args, 1, fixed.n + rest.n))
end
end
local function label(prefix, sep, value) return prefix .. sep .. value end
local tag = partial(label, "id", ":")
print(tag(42))एक व्यावहारिक उपयोग
आंशिक अनुप्रयोग सामान्य उपयोगिता फ़ंक्शन के साथ बहुत उपयोगी होता है। कॉन्फ़िगरेशन को एक बार तय कीजिए, फिर विशेषीकृत फ़ंक्शन का कई बार पुनः उपयोग कीजिए।
नीचे, एक सामान्य greet निश्चित-भाषा वाले अभिवादन फ़ंक्शन में बदल जाता है, जिसे केवल नाम की आवश्यकता होती है।
local function greet(lang, name)
if lang == "tr" then return "Merhaba, " .. name end
return "Hello, " .. name
end
local function bind1(f, a) return function(b) return f(a, b) end end
local greetTr = bind1(greet, "tr")
print(greetTr("Ada"))
print(greetTr("Lin"))आंशिक अनुप्रयोग और करीकरण
करीकरण बहु-आर्ग्युमेंट वाले फ़ंक्शन को एक-एक आर्ग्युमेंट वाले फ़ंक्शन की शृंखला में बदल देता है, जहाँ प्रत्येक अगला फ़ंक्शन लौटाता है। आंशिक अनुप्रयोग केवल कुछ आर्ग्युमेंट तय करता है और बाकी को सामान्य कॉल के रूप में रखता है।
दोनों संबंधित लेकिन अलग-अलग हैं: करीकरण एक-एक करके चलता है, जबकि आंशिक अनुप्रयोग कुछ आर्ग्युमेंट अभी तय करता है।
local function curryAdd(a)
return function(b)
return function(c)
return a + b + c
end
end
end
print(curryAdd(1)(2)(3))दो-आर्ग्युमेंट वाले फ़ंक्शन का करीकरण
एक छोटा सहायक किसी भी दो-आर्ग्युमेंट वाले फ़ंक्शन का अपने-आप करीकरण कर सकता है। यह पहले आर्ग्युमेंट का फ़ंक्शन लौटाता है, जो दूसरे आर्ग्युमेंट का फ़ंक्शन लौटाता है।
इससे पुनः उपयोग किए जा सकने वाले, एक-आर्ग्युमेंट वाले बिल्डर बनते हैं, जो डेटा-प्रवाह में अच्छे लगते हैं।
local function curry2(f)
return function(a)
return function(b)
return f(a, b)
end
end
end
local function pow(base, exp) return base ^ exp end
local cpow = curry2(pow)
print(cpow(2)(10))क्लोज़र इसे संभव बनाते हैं
हर आंशिक और करीकृत फ़ंक्शन क्लोज़र पर निर्भर करता है। तय किए गए आर्ग्युमेंट कैप्चर किए गए स्थानीय मान होते हैं, जिन्हें लौटाया गया फ़ंक्शन याद रखता है।
क्योंकि हर लौटाए गए फ़ंक्शन के अपने कैप्चर किए गए मान होते हैं, इसलिए आप सुरक्षित रूप से कई विशेषीकृत रूप बना सकते हैं।
local function bind1(f, a) return function(b) return f(a, b) end end
local function sub(x, y) return x - y end
local from100 = bind1(sub, 100)
local from10 = bind1(sub, 10)
print(from100(40))
print(from10(3))इसे कब उपयोग करें
जब आप किसी फ़ंक्शन को बार-बार उन्हीं शुरुआती आर्ग्युमेंट के साथ कॉल करते हैं, तब दोहराव हटाने के लिए आंशिक अनुप्रयोग का उपयोग कीजिए।
यह किसी फ़ंक्शन को ऐसे इंटरफ़ेस के अनुकूल बनाने में भी सहायक होता है, जिसमें कम आर्ग्युमेंट अपेक्षित हों, जैसे ऐसा कॉलबैक जो केवल एक मान भेजता है।
कॉन्फ़िगर किए गए कॉलबैक
आंशिक अनुप्रयोग मानचित्रण और छनाई के साथ अच्छी तरह काम करता है। आप कॉन्फ़िगरेशन वाले आर्ग्युमेंट को पहले से भर सकते हैं, ताकि कॉलबैक को केवल सूची के तत्व की आवश्यकता हो।
इससे आपका डेटा-प्रवाह साफ़ रहता है और आप व्यवहार को फिर भी समायोजित कर सकते हैं।
local function map(t, f) local o={} for i,v in ipairs(t) do o[i]=f(v) end return o end
local function bind1(f, a) return function(b) return f(a, b) end end
local function scale(factor, x) return factor * x end
local r = map({1,2,3,4}, bind1(scale, 10))
print(table.concat(r, ", "))त्वरित जाँच
इन दो संबंधित विचारों के बीच का अंतर याद कीजिए।
पुनरावलोकन
आंशिक अनुप्रयोग कुछ आर्ग्युमेंट तय करके एक नया फ़ंक्शन लौटाता है, जो बाकी आर्ग्युमेंट की अपेक्षा करता है। यह क्लोज़र से बनाया जाता है, जो तय किए गए मानों को कैप्चर करते हैं।
परिवर्ती संख्या वाले आर्ग्युमेंट पर आधारित partial सहायक इस तरीके को सामान्य बनाता है, जबकि करीकरण एक-आर्ग्युमेंट वाले फ़ंक्शन की शृंखला बनाता है। दोनों दोहराव कम करते हैं और फ़ंक्शन को कॉलबैक के अनुकूल बनाते हैं।
एआई शिक्षक के साथ Lua सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 40
- पाठ
- 159
अक्सर पूछे जाने वाले प्रश्न
क्या “आंशिक अनुप्रयोग” पाठ निःशुल्क है?
हाँ — Lua Academy अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “आंशिक अनुप्रयोग” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। Lua Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“आंशिक अनुप्रयोग” में मैं क्या सीखूँगा?
Function के तर्क पहले से भरें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Lua Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Lua Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Lua Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।
“आंशिक अनुप्रयोग” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Lua Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Lua Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।