बिना नाम के कार्य
सीधे शब्दों में कहें, एक मेमना बिना किसी नाम या एक अनाम फ़ंक्शन के एक फ़ंक्शन है। निष्पादन योग्य कोड का एक छोटा टुकड़ा, जिसे चारों ओर से पारित किया जा सकता है जैसे कि यह एक चर था। जावास्क्रिप्ट में:
function () {}; // very simple
आइए अब देखते हैं कि इन मेमनों के लिए कुछ उपयोग क्या हैं।
सार बॉयलरप्लेट कोड
लैम्बडा का उपयोग बॉयलरप्लेट कोड को दूर करने के लिए किया जा सकता है। उदाहरण के लिए लूप्स। हम दिन भर लिखने forऔर whileलूप करने के आदी हैं। लेकिन यह कोड है जो लिखा नहीं जाता है। हम लूप के अंदर कोड निकाल सकते हैं, लूप का सबसे महत्वपूर्ण हिस्सा है, और बाकी को अलग कर सकते हैं:
for (var i=0; i<array.length; i++) {
// do what something useful with array[i]
}
forEachसरणी वस्तुओं का उपयोग करके , बन जाता है:
array.forEach(function (element, index) {
// do something useful with element
// element is the equivalent of array[i] from above
});
उपरोक्त अमूर्त forEachउतने उपयोगी नहीं हो सकते हैं, लेकिन अन्य उच्च क्रम के कार्य हैं, जैसे , कि बहुत अधिक उपयोगी कार्य करते हैं। उदाहरण के लिए filter:
var numbers = [1, 2, 3, 4];
var even = [];
// keep all even numbers from above array
for (var i=0; i<numbers.length; i++) {
if (numbers[i] % 2 === 0) {
even.push(numbers[i]);
}
}
alert(even);
// Using the filter method
even = [1, 2, 3, 4].filter(function (number) {
return number % 2 === 0;
});
alert(even);
कोड निष्पादन में देरी
कुछ वातावरणों में, जिसमें घटना की अवधारणा उपलब्ध है, हम लैंबडास का उपयोग उन घटनाओं पर प्रतिक्रिया करने के लिए कर सकते हैं जो किसी समय में हो सकती हैं।
window.onload = function () {
alert("Loaded");
};
window.setTimeout(function () {
alert("Code executed after 2 seconds.");
}, 2000);
यह कुछ अन्य तरीकों से किया जा सकता था, लेकिन वे क्रियात्मक हैं। उदाहरण के लिए, जावा में Runnableइंटरफ़ेस है।
कार्यों का कारक
इस बिंदु तक, हमने केवल लैम्ब्डा का उपयोग ज्यादातर सिंटैक्टिक शुगर क्षमताओं के लिए किया। लेकिन ऐसी परिस्थितियां हैं जहां लंबोदर बहुत अधिक उपयोगी हो सकते हैं। उदाहरण के लिए हमारे पास ऐसे कार्य हो सकते हैं जो लैम्ब्डा लौटाते हैं। मान लें कि हमारे पास एक फ़ंक्शन है जो हम चाहते हैं कि इसके रिटर्न मान कैश किए जाएं।
var users = [];
var getUser = function (name) {
if (! users[name]) {
// expensive operations to get a user. Ajax for example
users[name] = user_from_ajax;
}
return users[name];
};
बाद में, हम देख सकते हैं कि हमारे पास एक समान कार्य है:
var photos = [];
var getPhoto = function (name) {
if (! photo[name]) {
// expensive operations to get a user. Ajax for example
photos[name] = photo_from_ajax;
}
return photos[name];
};
वहाँ स्पष्ट रूप से एक पैटर्न है, तो चलो इसे दूर करते हैं। आइए संस्मरण का उपयोग करें ।
/**
* @param {Array} store Data structure in which we cache lambda's return values
* @param {Function} lambda
* @return {Function} A function that caches the result of calling the lambda param
*/
var memoize = function (store, lambda) {
// return a new lambda
return function (name) {
if (! store[name]) {
// Execute the lambda and cache the result
store[name] = lambda(name);
}
return store[name];
};
};
var getUsers = memoize([], function (name) {
// expensive operations to get a user. Ajax for example
});
var getPhotos = memoize([], function (name) {
// expensive operations to get a photo. Ajax for example
});
जैसा कि आप देख सकते हैं, लैम्ब्डा का उपयोग करके, हम कैशिंग / मेमोइज़ेशन लॉजिक को दूर करने में सक्षम थे। यदि अन्य उदाहरण के लिए कुछ वर्कअराउंड थे, तो मेरा मानना है कि अन्य तकनीकों का उपयोग करके इस विशेष समस्या को मुश्किल से हल किया गया है। हम एक ही स्थान पर कुछ महत्वपूर्ण बॉयलरप्लेट कोड निकालने में कामयाब रहे। यह उल्लेख करने के लिए नहीं कि हमें usersऔर photosवैश्विक चर से छुटकारा मिल गया ।
आपके प्रोफ़ाइल को देखकर मुझे लगता है कि आप ज्यादातर पायथन उपयोगकर्ता हैं। उपरोक्त पैटर्न के लिए, पायथन में सज्जाकारों की अवधारणा है। संस्मरण सज्जाकारों के लिए नेट पर बहुत सारे उदाहरण हैं । फर्क सिर्फ इतना है कि पायथन में आपको सबसे अधिक नामांकित फ़ंक्शन उस डेकोरेटर फ़ंक्शन के अंदर है। इसका कारण यह है कि पायथन केवल एकल-अभिव्यक्ति वाले लैम्ब्डा का समर्थन करता है। लेकिन अवधारणा एक ही है।
पायथन लैम्बडा उपयोग के उदाहरण के रूप में। उपरोक्त कोड जिसमें हमने सम संख्याओं को फ़िल्टर किया है उसे इस तरह से पायथन में दर्शाया जा सकता है:
filter(lambda x: x % 2 == 0, [1, 2, 3, 4])
वैसे भी, लंबोदर बिना बंद किए शक्तिशाली नहीं हैं। क्लोज़र वही है जो लंबोदर की अवधारणा को इतना शक्तिशाली बनाता है। अपने संस्मरण उदाहरण में मैंने पैराम के चारों ओर एक क्लोजर बनाने के लिए क्लोजर का उपयोग किया है store। इस तरह, memoizeफ़ंक्शन के अपने परिणाम (एक लंबो) वापस आने के बाद भी मेरे पास उस परम तक पहुंच है ।