परिचय
क्लोज़र Clojure में प्रोग्रामिंग का एक तरीका हैं। इसकी मदद से बाहरी लेक्सिकल स्कोप के वेरिएबल किसी फंक्शन के अंदर इस्तेमाल किए जा सकते हैं। Clojure क्लोज़र को अपने आप सपोर्ट करता है, और अक्सर लोग इनका इस्तेमाल यह जाने बिना ही करते हैं कि ये क्या हैं।
;; Top-level definitions are global-scope
(def dozen 12)
;; Functions create a new scope.
;; Referencing the outer variable here is a closure.
(fn [n] (* dozen n))
स्थिति सहेजने और वैल्यू आगे भेजने के लिए क्लोज़र
एटम के इस्तेमाल से कुछ स्थिति सहेजी जा सकती है:
;; This function closure increments the counter's state
;; in the outer lexical context.
;; This way the counter can be shared between many calling contexts.
(def increment
(let [counter (atom 0)]
(fn [] (swap! counter inc))))
increment को हर बार कॉल करने पर उसका काउंटर एक बढ़ जाता है:
(increment)
;;=> 1
(increment)
;;=> 2
निर्देश
आपकी डिज़ाइन कंपनी मुख्य रूप से वेब पेज बनाने के लिए CSS ट्रांसफॉर्मेशन का उपयोग करती आ रही है। कुछ चर्चा के बाद यह निर्णय लिया गया कि कुछ गणनाएँ गतिशील रूप से करने के लिए Clojure का उपयोग शुरू किया जाए। आपके कुछ साथी Clojure में कम अनुभवी हैं, इसलिए आप {x, y} निर्देशांक जोड़ों के लिए दोबारा उपयोग किए जा सकने वाले ट्रांसफॉर्मेशन बनाने के लिए फंक्शन क्लोज़र का उपयोग करने का निर्णय लेते हैं।
1. निर्देशांकों को स्थानांतरित कीजिए
translate2d फंक्शन बनाइए जो एक फंक्शन लौटाता है जो क्लोज़र का उपयोग करके किसी निर्देशांक जोड़े का दोहराया जा सकने वाला 2d स्थानांतरण करता है।
(def move-coordinates-right-2px (translate2d 2 0))
(def result (move-coordinates-right-2px 4 8))
;; result => [6 8]
2. निर्देशांकों का स्केल बदलिए
scale2d फंक्शन बनाइए जो एक फंक्शन लौटाता है जो क्लोज़र का उपयोग करके किसी निर्देशांक जोड़े पर दोहराया जा सकने वाला 2d स्केल लागू करता है।
इस अभ्यास के लिए, मान लीजिए कि स्केलिंग वैल्यू केवल धनात्मक हैं।
(def double-scale (scale2d 2 2))
(def result (double-scale 6 -3))
;; result => [12 -6]
3. ट्रांसफॉर्मेशन फंक्शनों को मिलाइए
एक दोहराया जा सकने वाला ट्रांसफॉर्मेशन करने के लिए दो ट्रांसफॉर्मेशन फंक्शनों को मिलाइए। इसे अक्सर फंक्शन कंपोज़िशन कहा जाता है, जिसमें पहले फंक्शन 'f(x)' का परिणाम दूसरे फंक्शन 'g(x)' के इनपुट के रूप में उपयोग किया जाता है।
(def move-coordinates-right-2px (translate2d 2 0))
(def double-coordinates (scale2d 2 2))
(def composed-transformations
(compose-transform move-coordinates-right-2px
double-coordinates))
(def result (composed-transformations 0 1))
;; result => [4 2]
4. फंक्शनों के परिणाम संग्रहीत कीजिए
memoize-transform फंक्शन बनाइए। यह मेमोइज़ करने के लिए एक फंक्शन लेता है, फिर एक नया फंक्शन लौटाता है जो दिए गए फंक्शन के इनपुट याद रखता है ताकि पिछली रिटर्न वैल्यू याद रखी जा सके और अगर उसी आर्गुमेंट के साथ दोबारा कॉल किया जाए तो उसकी गणना केवल एक बार हो।
मेमोइज़िंग को कभी-कभी डायनैमिक प्रोग्रामिंग कहा जाता है; यह महँगे ऑपरेशनों को केवल एक बार करने देता है क्योंकि उनका परिणाम याद रखा जाता है।
(def triple-scale (scale2d 3 3))
(def memoized-scale (memoize-transform triple-scale))
(memoized-scale 4 3)
;; => [12, 9], this is computed since it hasn't been computed before for the arguments
(memoized-scale 4 3)
;; => [12, 9], this is remembered, since it was computed already
सीखने का अभ्यास
