क्लोजर

Question

में मजबूत डेटा एपीआई का निर्माण कैसे करें हाय दोस्तों: मुझे लगता है कि मेरे क्लोजर ऐप्स डेटा एपीआई की कमी के कारण संरचनात्मक रूप से बहुत तेजी से मिलते हैं ...- मेरे पास ऐसे कुंजी हैं जिनके नाम गलत हैं, अपवादों को फेंकने या त्रुटियों का कारण बनता है। मैंने यह भी ध्यान दिया कि किसी सूची को नष्ट करते समय गलतियों को करना आसान है (उदाहरण के लिए शायद आप सूची के गलत हिस्से को नष्ट कर सकते हैं) .....

जावा दुनिया से आ रहा है, आम तौर पर मैं अपने आईडीई का उपयोग करने में मेरी सहायता करता हूं कम से कम, अनियंत्रित डेटा ऑब्जेक्ट्स से "दाएं" डेटा --- लेकिन क्लोजर मैप पासिंग इस से विपरीत प्रतिमान प्रतीत होता है।

क्लोजुरियन कोड किसी प्रकार की प्रणाली या विचार कोड पूर्ण होने की अनुपस्थिति में रक्षात्मक रूप से कोड कैसे करते हैं ...?

Answer 1

लिखें अपने "स्कीमा" (चाबियाँ लेकिन यह भी मान आदि के प्रकार) के लिए काम करता है सत्यापनकर्ताओं तो thm अंदर पूर्व और अपने कोड में पोस्ट शर्तों का उपयोग - के बाद से अपने वाक्य रचना थोड़ा यहाँ जाना जाता है में एक संक्षिप्त विवरण है:

(defn foo [x y] ; works with fn too 
    {:pre [(number? x) (number? y)] 
    :post [(number? %) (pos? %)]} 
    (+ (* x x) (* y y))) 

वे assert पर भरोसा करते हैं और इसलिए अक्षम किया जा सकता है। अधिक जानकारी के लिए (doc assert)।

Answer 2

शायद आप रिकॉर्ड की तलाश में हैं?

(require '[clojure.set :as cset]) 

(defrecord Person [name age address phone email]) 

    ;; Make a keyword-based constructor to verify 
    ;; args and decouple ordering. 
(let [valid #{:name :age :address :phone :email}] 
    (defn mk-person[& args] 
    (let [h (apply hash-map args) 
      invalid (cset/difference (set (keys h)) valid)]  
     (when-not (empty? invalid) 
     (throw (IllegalArgumentException. (pr-str invalid)))) 
     ; any other argument validation you want here 
     (Person. 
     (:name h) (:age h) (:address h) (:phone h) (:email h))))) 

=> (def p (mk-person :name "John" :email "john@hotmail.com")) 
#:user.Person{:name "John", :age nil, :address nil, :phone nil, 
       :email "john@hotmail.com"} 

अब आप कार्य (अपवाद) या कीवर्ड (नहीं अपवाद) के साथ डेटा तक पहुँचने से है कि क्या आप गलत लिखे गए नाम के लिए अपवाद चाहते हैं चुन सकते हैं।

=> (.fax p) 
java.lang.IllegalArgumentException: 
    No matching field found: fax for class user.Person 
=> (:fax p) 
nil 

इस दृष्टिकोण के लिए आवश्यक है कि आप फ़ील्ड नामों से बचें जो मौजूदा तरीकों से संघर्ष करेंगे। (@Jouni से टिप्पणी देखें।)

वैकल्पिक रूप से, आप देखने के लिए कीवर्ड और एक्सेसर समारोह है कि अवैध चाबी के लिए जाँच करता है का उपयोग करके क्षेत्र का नाम सीमा बाईपास कर सकते हैं:

(defn get-value [k rec] 
    (let [v (k rec ::not-found)] 
    (if (= v ::not-found) 
     (throw (IllegalArgumentException. (pr-str k))) 
    v))) 

=> (get-value :name p) 
"John" 
=> (get-value :fax p) 
IllegalArgumentException: :fax 

---

"गलत Destructuring सूची का हिस्सा "-प्रकार समस्याएं सूची में" व्यक्ति "जैसी कुछ एन्कोड करने की कोशिश करने से आ सकती हैं; तो आपको 'व्यक्ति' सूची में तीन पदों पर 'पता' सूची में ज़िप कोड चौथा तत्व "जैसे कोड याद रखने की आवश्यकता है।

'क्लासिकल' लिस्प में आप क्लोजर में एक्सेसर फ़ंक्शंस लिखकर हल कर सकते हैं, आप रिकॉर्ड का उपयोग कर सकते हैं।

टाइपो किसी भी प्रोग्रामिंग भाषा में समस्याएं पैदा करेंगे, सबसे अच्छा आप उन्हें पकड़ने की कोशिश कर सकते हैं।

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

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