हम कोड अपघटन के बारे में एक शब्द डालेंगे: प्रासंगिक प्रोग्रामिंग

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

हम क्लजुरे भाषा के लिए उदाहरण देंगे, हालांकि, सिद्धांत खुद को अन्य कार्यात्मक प्रोग्रामिंग भाषाओं में लागू किया जा सकता है (उदाहरण के लिए, हम एर्लांग में बिल्कुल उसी विचार का उपयोग करते हैं)।

विचार

विचार स्वयं सरल है और निम्नलिखित कथनों पर आधारित है:

• किसी भी तर्क में हमेशा प्रारंभिक चरण होते हैं;
• प्रत्येक चरण के लिए, कुछ डेटा की आवश्यकता होती है, जिसके लिए यह अपने तर्क को लागू करता है और या तो एक सफल या असफल परिणाम पैदा करता है।

छद्म-कूट स्तर पर, इसे निम्नानुसार दर्शाया जा सकता है:

do-something-elementary(context) -> [:ok updated_context] | [:error reason]

जहां:

• do-something-elementary - फ़ंक्शन नाम;
• context - फ़ंक्शन तर्क, प्रारंभिक संदर्भ के साथ डेटा संरचना जिसमें से फ़ंक्शन सभी आवश्यक डेटा लेता है;
• updated_context - अद्यतन संदर्भ के साथ डेटा संरचना, यदि सफल हो, जहां फ़ंक्शन इसके निष्पादन का परिणाम जोड़ता है;
• reason - डेटा संरचना, विफलता का कारण, विफलता के साथ।

वह पूरा विचार है। और फिर - प्रौद्योगिकी का मामला। 100,500 मिलियन भागों के साथ।

उदाहरण: उपयोगकर्ता खरीदारी कर रहा है

हम एक ठोस सरल उदाहरण पर विवरण लिखेंगे, जो यहां GitHub पर उपलब्ध है ।
मान लीजिए कि हमारे पास पैसे वाले उपयोगकर्ता हैं और बहुत सारे हैं जिनके पास पैसे हैं और जो उपयोगकर्ता खरीद सकते हैं। हम एक कोड लिखना चाहते हैं जो बहुत की खरीद को पूरा करेगा:

buy-lot(user_id, lot_id) -> [:ok updated_user] | [:error reason]

सादगी के लिए, हम उपयोगकर्ता संरचना में बहुत सारे पैसे और उपयोगकर्ता की मात्रा को संग्रहीत करेंगे।

कार्यान्वयन के लिए, हमें कई सहायक कार्यों की आवश्यकता है।

until-first-error फ़ंक्शन

अधिकांश मामलों में, व्यावसायिक तर्क को उन चरणों के अनुक्रम के रूप में दर्शाया जा सकता है जिन्हें एक त्रुटि होने तक उठाए जाने की आवश्यकता होती है। ऐसा करने के लिए, हम एक फंक्शन बनाएंगे:

until-first-error(fs, init_context) -> [:ok updated_context] | [:error reason]

जहां:

• fs कार्यों का एक क्रम है (प्राथमिक क्रियाएं);
• init_context प्रारंभिक संदर्भ है।

इस सुविधा का कार्यान्वयन यहाँ GitHub पर देखा जा सकता है ।

with-result-or-error

बहुत बार, एक प्राथमिक कार्रवाई यह है कि आपको बस कुछ फ़ंक्शन को निष्पादित करने की आवश्यकता है और, यदि यह सफल रहा, तो इसके परिणाम को संदर्भ में जोड़ें। ऐसा करने के लिए, हमारे पास एक फ़ंक्शन है:

with-result-or-error(f, key, context) -> [:ok updated_context] | [:error reason]

सामान्य तौर पर, इस फ़ंक्शन का एकमात्र उद्देश्य कोड आकार को कम करना है।

और अंत में, हमारी "सुंदरता" ...

फ़ंक्शन जो खरीद को लागू करता है

 1. (defn buy-lot [user_id lot_id] 2. (let [with-lot-fn (partial 3. util/with-result-or-error 4. #(lot-db/find-by-id lot_id) 5. :lot) 6. 7. buy-lot-fn (fn [{:keys [lot] :as ctx}] 8. (util/with-result-or-error 9. #(user-db/update-by-id! 10. user_id 11. (fn [user] 12. (let [wallet_v (get-in user [:wallet :value]) 13. price_v (get-in lot [:price :value])] 14. (if (>= wallet_v price_v) 15. (let [updated_user (-> user 16. (update-in [:wallet :value] 17. - 18. price_v) 19. (update-in [:lots] 20. conj 21. {:lot_id lot_id 22. :price price_v}))] 23. [:ok updated_user]) 24. [:error {:type :invalid_wallet_value 25. :details {:code :not_enough 26. :provided wallet_v 27. :required price_v}}])))) 28. :user 29. ctx)) 30. 31. fs [with-lot-fn 32. buy-lot-fn]] 33. 34. (match (util/until-first-error fs {}) 35. 36. [:ok {:user updated_user}] 37. [:ok updated_user] 38. 39. [:error reason] 40. [:error reason]))) 

कोड के माध्यम से चलते हैं:

• पी। 34: match clojure.core.match लाइब्रेरी से टेम्पलेट से मिलान मूल्यों के लिए एक मैक्रो है;
• पी। 34-40: हम प्राथमिक कदमों until-first-error फ़ंक्शन का वादा किया हुआ आवेदन करते हैं, संदर्भ से हमें जो डेटा चाहिए उसे लेते हैं और उसे वापस करते हैं, या त्रुटि को फेंक देते हैं;
• पी। 2-5: हम पहली प्राथमिक कार्रवाई का निर्माण कर रहे हैं (जिस पर केवल वर्तमान संदर्भ लागू किया जाएगा), जो बस कुंजी पर डेटा जोड़ता है :lot वर्तमान संदर्भ के लिए :lot ;
• पी। 7-29: यहां हम परिचित फ़ंक्शन with-result-or-error उपयोग करते हैं, लेकिन यह जो कार्रवाई करता है वह थोड़ा पेचीदा हो जाता है: एक लेनदेन में, हम जांचते हैं कि उपयोगकर्ता के पास पर्याप्त पैसा है और, यदि सफल हो, तो हम खरीदारी करते हैं (क्योंकि , डिफ़ॉल्ट रूप से हमारा एप्लिकेशन मल्टीथ्रेडेड है (और जो कहीं आखिरी बार एक-पिरोया आवेदन देखा?) और हमें इसके लिए तैयार रहना चाहिए)।

और हमारे द्वारा उपयोग किए जाने वाले अन्य कार्यों के बारे में कुछ शब्द:

• lot-db/find-by-id(id) - बहुत कुछ लौटाता है, id द्वारा;
• user-db/update-by-id!(user_id, update-user-fn) - उपयोगकर्ता user_id (एक काल्पनिक डेटाबेस में) में update-user-fn user_id update-user-fn फ़ंक्शन लागू करता है।

और परीक्षण करने के लिए? ...

क्लोजर REPL से इस नमूना आवेदन का परीक्षण करें। हम प्रोजेक्ट रूट से कंसोल से REPL शुरू करते हैं:

 lein repl 

वित्त के साथ हमारे उपयोगकर्ता क्या हैं:

 context-aware-app.core=> (context-aware-app.user.db/enumerate) [:ok ({:id "1", :name "Vasya", :wallet {:value 100}, :lots []} {:id "2", :name "Petya", :wallet {:value 100}, :lots []})] 

हमारे पास बहुत सारे (माल) हैं:

 context-aware-app.core=> (context-aware-app.lot.db/enumerate) [:ok ({:id "1", :name "Apple", :price {:value 10}} {:id "2", :name "Banana", :price {:value 20}} {:id "3", :name "Nuts", :price {:value 80}})] 

वासा एक सेब खरीदता है:

 context-aware-app.core=>(context-aware-app.processing/buy-lot "1" "1") [:ok {:id "1", :name "Vasya", :wallet {:value 90}, :lots [{:lot_id "1", :price 10}]}] 

और केला:

 context-aware-app.core=> (context-aware-app.processing/buy-lot "1" "2") [:ok {:id "1", :name "Vasya", :wallet {:value 70}, :lots [{:lot_id "1", :price 10} {:lot_id "2", :price 20}]}] 

और "नट":

 context-aware-app.core=> (context-aware-app.processing/buy-lot "1" "3") [:error {:type :invalid_wallet_value, :details {:code :not_enough, :provided 70, :required 80}}] 

नट के लिए पर्याप्त धन नहीं था।

कुल मिलाकर

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

• कोड पढ़ने और समझने पर समय की बचत;
• सरलीकृत कोड परीक्षण
• कोड का पुन: उपयोग करने की क्षमता (कॉपी-पेस्ट + डॉपिलिवनी फ़ाइल का उपयोग करके);
• कोड रीफैक्टरिंग का सरलीकरण।

यानी वह सब जिससे हम प्यार करते हैं और अभ्यास करते हैं।