clojure
क्लोजर विनाशकारी

एक वेक्टर को नष्ट करना

यहां बताया गया है कि आप वेक्टर को कैसे नष्ट कर सकते हैं:

(def my-vec [1 2 3])

फिर, उदाहरण के लिए, let ब्लॉक के भीतर, आप वेक्टर से मानों को बहुत संक्षेप में निकाल सकते हैं:

(let [[x y] my-vec]
 (println "first element:" x ", second element: " y))
;; first element: 1 , second element: 2

एक नक्शे को नष्ट करना

यहां बताया गया है कि आप नक्शे को कैसे नष्ट कर सकते हैं:

(def my-map {:a 1 :b 2 :c 3})

फिर, उदाहरण के लिए, एक ब्लॉक के भीतर आप मानचित्र से मानों को बहुत संक्षेप में निकाल सकते हैं:

(let [{x :a y :c} my-map]
  (println ":a val:" x ", :c val: " y))
;; :a val: 1 , :c val: 3

ध्यान दें कि प्रत्येक मैपिंग में निकाले जा रहे मान बाईं ओर हैं और वे जिन कुंजियों से जुड़े हैं, वे दाईं ओर हैं।

यदि आप मानों को बाँधने के लिए मानों को नष्ट करना चाहते हैं तो कुंजी के रूप में आप इस शॉर्टकट का उपयोग कर सकते हैं:

(let [{:keys [a c]} my-map]
  (println ":a val:" a ", :c val: " c))
;; :a val: 1 , :c val: 3

यदि आपकी चाबियाँ तार हैं तो आप लगभग समान संरचना का उपयोग कर सकते हैं:

(let [{:strs [foo bar]} {"foo" 1 "bar" 2}]
  (println "FOO:" foo  "BAR: " bar ))
;; FOO: 1 BAR: 2

और प्रतीकों के लिए इसी तरह:

(let [{:syms [foo bar]} {'foo 1 'bar 2}]
  (println "FOO:" foo "BAR:" bar))
;; FOO: 1 BAR: 2

यदि आप एक नेस्टेड मैप को नष्ट करना चाहते हैं, तो आप ऊपर बताए गए बंधन-रूपों को घोंसला बना सकते हैं:

(def data
  {:foo {:a 1
         :b 2}
   :bar {:a 10
         :b 20}})

(let [{{:keys [a b]} :foo
       {a2 :a b2 :b} :bar} data]
  [a b a2 b2])
;; => [1 2 10 20]

शेष तत्वों को एक क्रम में नष्ट करना

मान लीजिए कि आपके पास एक वेक्टर है जैसे:

(def my-vec [1 2 3 4 5 6])

और आप पहले 3 तत्वों को निकालना चाहते हैं और शेष तत्वों को एक अनुक्रम के रूप में प्राप्त करना चाहते हैं। इसे इस प्रकार किया जा सकता है:

(let [[x y z & remaining] my-vec]
 (println "first:" x ", second:" y "third:" z "rest:" remaining))
;= first: 1 , second: 2 third: 3 rest: (4 5 6)

विनाशकारी नेस्टेड वैक्टर

आप नेस्टेड वैक्टर को नष्ट कर सकते हैं:

(def my-vec [[1 2] [3 4]])

(let [[[a b][c d]] my-vec]
  (println a b c d))
;; 1 2 3 4

डिफ़ॉल्ट मानों के साथ एक मानचित्र को नष्ट करना

कभी-कभी आप एक ऐसे मानचित्र के तहत कुंजी को नष्ट करना चाहते हैं, जो मानचित्र में मौजूद नहीं हो सकता है, लेकिन आप नष्ट हुए मूल्य के लिए एक डिफ़ॉल्ट मान चाहते हैं। आप इस तरह से कर सकते हैं:

(def my-map {:a 3 :b 4})
(let [{a :a
       b :b
       :keys [c d]
       :or {a 1
            c 2}} my-map]
  (println a b c d))
  ;= 3 4 2 nil

एक fn के विनाशकारी params

विनाशकारी कई स्थानों पर काम करता है, साथ ही एक fn की परम सूची में:

(defn my-func [[_ a b]]
  (+ a b))

(my-func [1 2 3]) ;= 5
(my-func (range 5)) ;= 3

विनाश भी परम सूची में & rest निर्माण के लिए काम करता है:

(defn my-func2 [& [_ a b]]
  (+ a b))

(my-func2 1 2 3) ;= 5
(apply my-func2 (range 5)) ;= 3

अनुक्रम के बाकी हिस्सों को एक नक्शे में बदलना

विनाशकारी आपको नक्शे के रूप में अनुक्रम की व्याख्या करने की क्षमता भी देता है:

(def my-vec [:a 1 :b 2])
(def my-lst '("smthg else" :c 3 :d 4))

(let [[& {:keys [a b]}] my-vec
      [s & {:keys [c d]} my-lst]
  (+ a b c d)) ;= 10

यह नामित मापदंडों के साथ कार्यों को परिभाषित करने के लिए उपयोगी है:

(defn my-func [a b & {:keys [c d] :or {c 3 d 4}}]
  (println a b c d))

(my-func 1 2) ;= 1 2 3 4
(my-func 3 4 :c 5 :d 6) ;= 3 4 5 6

अवलोकन

विनाशकारी आपको विभिन्न वस्तुओं से अलग-अलग चर में डेटा निकालने की अनुमति देता है। नीचे दिए गए प्रत्येक उदाहरण में, प्रत्येक चर को अपनी स्ट्रिंग ( a = "a" , b = "b" , और c) को सौंपा गया है।

सुझाव:

• डिफ़ॉल्ट मानों का उपयोग करके प्रदान किया जा सकता है :or , अन्यथा डिफ़ॉल्ट nil
• का प्रयोग करें & rest एक स्टोर करने के लिए seq में किसी भी अतिरिक्त मूल्यों के rest , अन्यथा अतिरिक्त मूल्यों अनदेखी कर रहे हैं
• विनाश का एक आम और उपयोगी उपयोग फ़ंक्शन मापदंडों के लिए है
• आप अवांछित भागों को फेंक-फेंक चर (पारंपरिक रूप से: _ ) में असाइन कर सकते हैं

विध्वंस करना और कुंजियों के नाम पर बांधना

कभी-कभी मानचित्रों को नष्ट करते समय, आप विनाशकारी मूल्यों को उनके संबंधित नाम से बांधना चाहेंगे। डेटा संरचना की ग्रैन्युलैरिटी के आधार पर, मानक विनाशकारी योजना का उपयोग करके थोड़ी सी क्रिया हो सकती है।

मान लीजिए, हमारे पास मानचित्र आधारित रिकॉर्ड है जैसे:

(def john {:lastname "McCarthy" :firstname "John" :country "USA"})

हम आम तौर पर इसे ऐसे ही नष्ट कर देंगे:

(let [{lastname :lastname firstname :firstname country :country} john]
    (str firstname " " lastname ", " country))
;;"John McCarthy, USA"

यहाँ, डेटा संरचना केवल 3 स्लॉट्स ( firstname, lastname, country ) के साथ काफी सरल है , लेकिन कल्पना करें कि अधिक दानेदार डेटा संरचना के लिए दो बार सभी प्रमुख नामों को दोहराना कितना बोझिल होगा (केवल 3 से अधिक स्लॉट वाले तरीके) ।

इसके बजाय, इसका उपयोग करने का एक बेहतर तरीका है :keys (चूंकि हमारी कुंजियाँ यहाँ खोजशब्द हैं) और कुंजी नाम का चयन करते हुए हम इसे पसंद करना चाहते हैं:

(let [{:keys [firstname lastname country]} john]
    (str firstname " " lastname ", " country))
;;"John McCarthy, USA"

एक ही सहज ज्ञान युक्त तर्क अन्य प्रमुख प्रकारों के लिए लागू होता है जैसे प्रतीक (उपयोग करना :syms ) और सादे पुराने तार (उपयोग करना :strs )

;; using strings as keys
(def john {"lastname" "McCarthy" "firstname" "John" "country" "USA"})
;;#'user/john

;; destructuring string-keyed map
(let [{:strs [lastname firstname country]} john]
    (str firstname " " lastname ", " country))
;;"John McCarthy, USA"

;; using symbols as keys
(def john {'lastname "McCarthy" 'firstname "John" 'country "USA"})

;; destructuring symbol-keyed map
(let [{:syms [lastname firstname country]} john]
    (str firstname " " lastname ", " country))
;;"John McCarthy, USA"

नष्ट करना और मूल तर्क मूल्य को एक नाम देना

(defn print-some-items 
   [[a b :as xs]]
  (println a)
  (println b)
  (println xs))

(print-some-items [2 3])

यह उदाहरण आउटपुट को प्रिंट करता है

2
3
[2 3]

तर्क को नष्ट कर दिया जाता है और आइटम 2 और 3 को a और b के प्रतीकों को सौंपा जाता है। मूल तर्क, संपूर्ण वेक्टर [2 3] , प्रतीक xs को भी सौंपा गया है।