कैसे एक राज्य मशीन के साथ पैर में खुद को शूट करने के लिए नहीं

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

कटौती के तहत, आपको AppsConf पर अलेक्जेंडर साइशेव के भाषण ( ब्रेन89 ) का एक विस्तारित प्रतिलेख मिलेगा , जिसमें उन्होंने गैर-गेम एप्लिकेशन विकसित करने में राज्य मशीन का उपयोग करने के लिए अपने विकल्प साझा किए।


स्पीकर के बारे में: अलेक्जेंडर साइशेव आठ वर्षों के लिए आईओएस विकास में लगे हुए हैं, इस दौरान उन्होंने सामाजिक नेटवर्क और वित्तीय क्षेत्र के लिए सरल अनुप्रयोगों और जटिल ग्राहकों दोनों के निर्माण में भाग लिया। फिलहाल, Sberbank में एक तकनीकी लीड है।

वे कई क्षेत्रों से प्रोग्रामिंग करने के लिए आते हैं, विभिन्न पृष्ठभूमि और अनुभव रखते हैं, इसलिए पहले हम मूल सिद्धांत को याद करते हैं।

समस्या का बयान

एक राज्य मशीन एक गणितीय अमूर्त है जिसमें तीन मुख्य तत्व होते हैं:

• कई आंतरिक स्थिति
• इनपुट संकेतों का सेट जो वर्तमान स्थिति से अगले तक संक्रमण का निर्धारण करता है,
• अंतिम अवस्था के सेट, जिस पर ऑटोमेटन अपना कार्य पूरा करता है ("इनपुट शब्द x स्वीकार करता है")।

राज्य

राज्य से हमारा आशय एक चर या चर के समूह से है जो किसी वस्तु के व्यवहार को निर्धारित करता है। उदाहरण के लिए, मानक iOS एप्लिकेशन "सेटिंग्स " में एक आइटम "बोल्ड" ("बेसिक → यूनिवर्सल एक्सेस") है। इस आइटम का मूल्य आपको डिवाइस डिस्प्ले पर पाठ प्रदर्शित करने के लिए दो विकल्पों के बीच स्विच करने की अनुमति देता है।



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

पारंपरिक कार्य

व्यवहार में, प्रोग्रामर अक्सर एक परिमित राज्य मशीन के पार आते हैं।

गेमिंग अनुप्रयोगों

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

एक ही सिग्नल को संसाधित करते समय सिस्टम का व्यवहार लेकिन एक अलग आंतरिक स्थिति के साथ निम्नलिखित उदाहरणों द्वारा चित्रित किया जा सकता है। उदाहरण के लिए:

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



● खेल को रोक दिया गया है - वर्तमान फ्रेम को खींचने की कोई आवश्यकता नहीं है; मेनू मोड या गेम प्रक्रिया में खिलाड़ी - रेंडरिंग पूरी तरह से अलग है।

पाठ विश्लेषण

राज्य मशीन के उपयोग से जुड़े सबसे लोकप्रिय पाठ विश्लेषण कार्यों में से एक स्पैम फिल्टर है। चलो स्टॉप शब्दों का एक सेट और एक इनपुट अनुक्रम हो। आपको या तो इस अनुक्रम को फ़िल्टर करना होगा या इसे बिल्कुल भी प्रदर्शित नहीं करना चाहिए।



औपचारिक रूप से, यह स्ट्रिंग में एक विकल्प खोजने का कार्य है। इसे हल करने के लिए, नट-मॉरिस-प्रैट एल्गोरिथ्म का उपयोग किया जाता है, जिसमें से सॉफ्टवेयर कार्यान्वयन एक परिमित राज्य मशीन है। राज्य इनपुट अनुक्रम और पैटर्न में पाए जाने वाले वर्णों की संख्या है - स्टॉप वर्ड।

इसके अलावा, नियमित अभिव्यक्तियों का विश्लेषण करते समय , परिमित राज्य मशीनों का अक्सर उपयोग किया जाता है।

समानांतर क्वेरी प्रसंस्करण

एक राज्य मशीन अनुरोध प्रसंस्करण को लागू करने और निर्देशों के एक सख्त सेट को निष्पादित करने के लिए विकल्पों में से एक है।



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

सामान्य तौर पर, समस्याओं के दो वर्ग प्राप्त होते हैं:

• एक जटिल आंतरिक राज्य के साथ एक जटिल वस्तु के तर्क का प्रबंधन,
• नियंत्रण और डेटा प्रवाह का गठन (एल्गोरिथ्म का वर्णन)।

जाहिर है, ऐसे सामान्य कार्य किसी भी प्रोग्रामर के अभ्यास में सामने आते हैं। इसलिए, एक राज्य मशीन का उपयोग संभव है, जिसमें गैर-गेमिंग, सामग्री एप्लिकेशन शामिल हैं, जो अधिकांश मोबाइल डेवलपर्स में शामिल हैं।

अगला, हम यह विश्लेषण करेंगे कि ठेठ आईओएस एप्लिकेशन बनाने के लिए राज्य मशीन का उपयोग कहां और कब किया जा सकता है।

अधिकांश मोबाइल एप्लिकेशन में एक स्तरित वास्तुकला है। तीन आधार परतें हैं।

• प्रस्तुति परत।
• व्यापार तर्क परत।
• सहायक, नेटवर्क क्लाइंट और इतने पर (कोर परत) का एक सेट।

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



मॉडल-व्यू-कंट्रोलर के शास्त्रीय वास्तुशिल्प रूपक में, राज्य नियंत्रक में होगा: यह तय करता है कि दृश्य में क्या दिखाया गया है और इनपुट संकेतों का जवाब कैसे दिया जाए: एक बटन दबाने, स्लाइडर को बदलने, और इसी तरह। यह तर्कसंगत है कि नियंत्रक के कार्यान्वयन में से एक राज्य मशीन है।



VIPER में, राज्य प्रस्तुतकर्ता में है: यह वह है जो वर्तमान स्क्रीन से विशिष्ट नेविगेशन संक्रमण और दृश्य में डेटा के प्रदर्शन को निर्धारित करता है।



मॉडल-व्यू-व्यूमॉडल में, राज्य ViewModel में है। भले ही हमारे पास प्रतिक्रियाशील बाइंडर्स हों या न हों, MVVM रूपक में परिभाषित मॉड्यूल का व्यवहार ViewModel में दर्ज किया जाएगा। जाहिर है, राज्य मशीन के माध्यम से इसका कार्यान्वयन एक स्वीकार्य विकल्प है।



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



अधिक विशिष्ट कार्यों में, जैसे कि भुगतान मॉड्यूल, जिसमें राज्यों का एक व्यापक सेट, जटिल तर्क, एक राज्य मशीन का उपयोग भी सही है।

नतीजतन, हम पाते हैं कि मोबाइल एप्लिकेशन में ऐसी कई वस्तुएं हैं जिनके व्यवहार और स्थिति के तर्क को एक वाक्य की तुलना में अधिक जटिल बताया गया है। उन्हें प्रबंधित करने में सक्षम होना चाहिए।

एक वास्तविक उदाहरण पर विचार करें और समझें कि एक परिमित राज्य मशीन किस बिंदु पर वास्तव में आवश्यक है, और जहां इसका आवेदन उचित नहीं है।



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


या तो वास्तविक डेटा या एक त्रुटि प्रदर्शन को प्रेषित किया जा सकता है। तो पहला सशर्त ऑपरेटर दिखाई देता है, पहली शाखा, जो आवेदन के आगे के व्यवहार को निर्धारित करता है।

अगला सवाल यह है कि अगर कोई डेटा नहीं है तो क्या करें। क्या यह स्थिति एक त्रुटि है? सबसे अधिक संभावना नहीं: प्रत्येक समाचार में उपयोगकर्ता टिप्पणियां नहीं हैं। उदाहरण के लिए, मिस्र में हॉकी किसी के लिए बहुत कम रुचि है; ऐसे लेख में आमतौर पर कोई टिप्पणी नहीं होती है। यह सामान्य व्यवहार और स्क्रीन की सामान्य स्थिति है जिसे आपको प्रदर्शित करने में सक्षम होना चाहिए। तो दूसरा सशर्त ऑपरेटर दिखाई देता है।

यह मानना ​​तर्कसंगत है कि एक प्रारंभ स्थिति भी है जिसमें उपयोगकर्ता डेटा की उम्मीद करता है (उदाहरण के लिए, जब टिप्पणी स्क्रीन केवल स्क्रीन पर दिखाई देती है)। इस स्थिति में, लोडिंग संकेतक को सही ढंग से प्रदर्शित करें। यह तीसरा सशर्त बयान है।

इसलिए हमारे पास पहले से ही एक साधारण स्क्रीन पर चार राज्य हैं, जिनमें से प्रदर्शित तर्क का वर्णन इफ-इफ-इफ-इ-कंस्ट्रक्शन के माध्यम से किया गया है।



लेकिन अगर ऐसे और राज्य हैं तो क्या होगा? स्क्रीन का पुनरावृत्त विकास सशर्त निर्माणों, झंडों का एक गुच्छा, या एक बोझिल कई स्विच-केस की जटिल उलझन की ओर जाता है। यह कोड डरावना है। कल्पना कीजिए कि डेवलपर जो उसका समर्थन करेगा वह जानता है कि आप कहां रहते हैं और उसके पास एक चेनसॉ है जो वह हमेशा उसके साथ रहता है। और आप वास्तव में अपनी छोटी लेकिन अच्छी तरह से योग्य पेंशन के लिए जीना चाहते हैं।

मुझे लगता है कि इस मामले में यह विचार करने योग्य है कि क्या यह आवेदन में इस तरह के कार्यान्वयन को छोड़ने के लायक है।

कमियों

आइए समझते हैं कि हमें इस कोड के बारे में क्या पसंद नहीं है।



सबसे पहले, यह पढ़ना मुश्किल है ।

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

यह कोड लचीला नहीं है । यदि आपको एक नया राज्य जोड़ने की आवश्यकता है जो वर्तमान सीढ़ी से पालन नहीं करता है, तो यह बिल्कुल सफल नहीं हो सकता है! यदि आपको एक मार्ग से गुजरने की आवश्यकता है - अचानक इस सीढ़ी पर गुजरने वाले चेक को छोड़ दें - यह कैसे करना है? लगभग कुछ भी नहीं।

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

संकेतित कमियों का समाधान क्या हो सकता है? बेशक, यह प्रत्येक मॉड्यूल / नियंत्रक / जटिल वस्तु के तर्क का निर्माण है, जो अंतर्ज्ञान पर आधारित नहीं है, लेकिन एक अच्छा औपचारिक दृष्टिकोण का उपयोग कर रहा है। उदाहरण के लिए, एक परिमित राज्य मशीन।

GameplayKit

एक उदाहरण के रूप में , हम वही लेते हैं जो Apple प्रदान करता है। गेमप्लेकिट ढांचे के ढांचे के भीतर, दो वर्ग हैं जो राज्य मशीन के साथ काम करने में हमारी मदद करते हैं।

• GKState।
• GKStateMachine।

रूपरेखा का नाम यह स्पष्ट करता है कि Apple खेलों में उपयोग करना चाहता था। लेकिन गैर-गेमिंग अनुप्रयोगों में, यह उपयोगी होगा।



GKState वर्ग राज्य को परिभाषित करता है। इसका वर्णन करने के लिए, आपको सरल कदम उठाने की आवश्यकता है। हमें इस वर्ग से विरासत में मिला है, राज्य का नाम निर्धारित किया है, और तीन तरीकों को परिभाषित किया है।

• isValidNextState - वर्तमान स्थिति पिछले एक के आधार पर मान्य है या नहीं।
• didEnterFrom - इस राज्य में संक्रमण पर कार्रवाई।
• willExitTo - इस स्थिति से बाहर निकलते समय क्रियाएँ।

GKStateMachine एक राज्य मशीन वर्ग है। यह और भी आसान है। यह दो क्रियाएं करने के लिए पर्याप्त है।

• हम शुरुआती राज्यों के माध्यम से टाइप किए गए सरणी में इनपुट राज्यों के सेट को पास करते हैं।
• हम प्रवेश विधि का उपयोग करके इनपुट संकेतों के आधार पर संक्रमण करते हैं। इसके माध्यम से, प्रारंभिक स्थिति भी निर्धारित की जाती है।

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

राज्यों और उनके बीच संक्रमण

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

संक्रमण ग्राफ में ऐसे राज्य हैं जिन्हें नामों से वर्णित किया गया है, और तीर जो इन राज्यों को संक्रमण का वर्णन करने के लिए जोड़ते हैं। उदाहरण में, एक प्रारंभिक स्थिति है - हम डेटा की अपेक्षा कर रहे हैं - और तीन राज्य हैं जिन्हें प्रारंभिक एक से पहुँचा जा सकता है: प्राप्त डेटा, कोई डेटा और त्रुटि नहीं।



कार्यान्वयन में, हमें चार छोटे वर्ग मिलते हैं।



"डेटा लंबित" स्थिति का विश्लेषण करें। प्रवेश द्वार पर, यह डाउनलोड संकेतक प्रदर्शित करने के लायक है। और जब आप इस स्थिति से बाहर निकलते हैं , तो इसे छिपाएं। ऐसा करने के लिए, आपको ViewController का एक कमजोर लिंक होना चाहिए, जिसे बनाई गई राज्य मशीन द्वारा नियंत्रित किया जाता है।

मशीन मापदंडों

दूसरा चरण जिसे करने की आवश्यकता है वह है राज्य मशीन के मापदंडों को निर्धारित करना। ऐसा करने के लिए, राज्य बनाएं और उन्हें ऑटोमेटन ऑब्जेक्ट में स्थानांतरित करें।



प्रारंभिक अवस्था निर्धारित करना भी सुनिश्चित करें



सिद्धांत रूप में, सब कुछ, मशीन तैयार है। अब बाहरी घटनाओं पर प्रतिक्रियाओं को संसाधित करना आवश्यक है, जिससे ऑटोमेटन की स्थिति बदल रही है।



समस्या के कथन को याद करें। हमें अगर-और से एक सीढ़ी मिली, जिसके आधार पर यह तय किया गया कि क्या कार्रवाई की जानी चाहिए। एक सरल ऑटोमेटोन के नियंत्रण के रूप में, ऐसा कार्यान्वयन विकल्प हो सकता है (वास्तव में, एक साधारण स्विच - यह एक परिमित राज्य मशीन का एक आदिम कार्यान्वयन है), लेकिन हम व्यावहारिक रूप से पहले उल्लिखित कमियों से छुटकारा नहीं पाते हैं।

एक और दृष्टिकोण है जो आपको इन सीढ़ी से दूर जाने की अनुमति देगा। यह प्रोग्रामिंग के क्लासिक्स द्वारा प्रस्तावित है - तथाकथित "चार का गिरोह।"



एक विशेष डिज़ाइन पैटर्न है, जिसे "स्थिति" कहा जाता है।



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

मानक ढांचे को पता नहीं है कि कैसे। उनका सुझाव है कि GKStateMachine निर्णय लेगा। इसलिए, हम एक नई विधि के साथ परिमित राज्य मशीन का विस्तार करते हैं, जहां एक कॉन्फ़िगरेशन के रूप में हम सभी सशर्त चर के विवरण को पारित करते हैं जो विशिष्ट रूप से अगले राज्य का निर्धारण करते हैं। इस पद्धति के अंदर, आप अगले राज्य के चयन को वर्तमान में सौंप सकते हैं।



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



गेमप्लेकिट के फायदे।

• मानक पुस्तकालय। कुछ भी डाउनलोड करने की आवश्यकता नहीं है, कोकोपोड्स या कार्टेज का उपयोग करें।
• पुस्तकालय सीखने में काफी आसान है।
• एक साथ दो कार्यान्वयन हैं: उद्देश्य-सी पर और स्विफ्ट पर।

नुकसान:

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

परिमित राज्य मशीन कार्यान्वयन और क्या हैं? GitHub पर एक नज़र डालें।

उद्देश्य-सी कार्यान्वयन

TransitionKit

यह एक लंबे समय के लिए सबसे लोकप्रिय ऑब्जेक्टिव-सी लाइब्रेरी है, जो गेमप्लेकिट में पहचानी गई कमियों से रहित है। यह हमें एक स्टेट मशीन और ब्लॉकों पर इससे जुड़ी सभी क्रियाओं को लागू करने की अनुमति देता है।

राज्य संक्रमणों से अलग है ।

TransitionKit के भीतर 2 वर्ग हैं।

1. TKState - राज्यों और इनपुट, आउटपुट कार्यों की स्थापना के लिए।
2. TKEvent संक्रमण का वर्णन करने के लिए एक वर्ग है।
   TKEvent कुछ राज्यों को दूसरों से बांधता है। घटना को केवल एक स्ट्रिंग द्वारा परिभाषित किया गया है।

इसके अतिरिक्त, अतिरिक्त लाभ हैं।

आप संक्रमण के दौरान उपयोगी डेटा स्थानांतरित कर सकते हैं । NSNotificationCenter का उपयोग करते समय यह उसी तरह काम करता है। सभी उपयोगी पेलोड userInfo शब्दकोश के रूप में आता है, और उपयोगकर्ता सूचना को पार्स करता है।

गलत संक्रमण का वर्णन है । जब हम एक असंभव-असंभव संक्रमण बनाने की कोशिश करते हैं - संक्रमण विधि से लौटने पर हमें न केवल कोई मान नहीं मिलता है, बल्कि त्रुटि का एक विस्तृत विवरण भी है, जो एक राज्य मशीन को डीबग करते समय उपयोगी होता है।



TransitionKit का उपयोग लोकप्रिय RestKit नेटवर्क हारवेस्टर में किया जाता है। यह एक बहुत अच्छा उदाहरण है कि कैसे एक राज्य मशीन का उपयोग नेटवर्क के संचालन को लागू करते समय अनुप्रयोग कर्नेल में किया जा सकता है।



RestKit का एक विशेष वर्ग है - RKOperationStateMachine - समवर्ती संचालन के प्रबंधन के लिए। इनपुट पर, यह संसाधित किए जा रहे ऑपरेशन और इसके निष्पादन के लिए कतार को स्वीकार करता है।



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

अपने ऑटोमेटन से जुड़ा एक ऑपरेशन बाहरी घटनाओं को ऑटोमेटन में स्थानांतरित करता है, और यह राज्यों और सभी संबंधित कार्यों के बीच संक्रमण करता है। राज्य मशीन का ख्याल रखती है

• अतुल्यकालिक कोड निष्पादन,
• संक्रमण के दौरान परमाणु कोड निष्पादन,
• संक्रमण नियंत्रण
• संचालन रद्द करना
• ऑपरेशन राज्य चर के परिवर्तन की शुद्धता: isReady, isExecuting, isFinished।

पाली

TransitionKit के अलावा, यह अलग-अलग Shift का उल्लेख करने योग्य है - NSObject पर एक श्रेणी के रूप में लागू एक छोटा पुस्तकालय। यह दृष्टिकोण आपको किसी भी मशीन को स्टेट मशीन में बदलने की अनुमति देता है, जो संक्रमण के दौरान ब्लॉकों में स्ट्रिंग स्थिरांक और क्रियाओं के रूप में अपने राज्य का वर्णन करता है। बेशक, यह एक प्रशिक्षण परियोजना का अधिक है, लेकिन काफी दिलचस्प है और आपको यह कोशिश करने की अनुमति देता है कि राज्य मशीन न्यूनतम लागत पर क्या है।

स्विफ्ट कार्यान्वयन

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

SwiftyStateMachine

SwiftyStateMachine में, राज्य मशीन को एक गैर-स्थिर संरचना द्वारा दर्शाया जाता है, संपत्ति के didSet तरीकों के माध्यम से, आप आसानी से राज्य परिवर्तनों को पकड़ सकते हैं।

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



, .

• .
  , .
• .
  state machine , state machine.
• , , .
• , DOT.
  state- — DOT. , , .

निष्कर्ष

.

• .
  , . , . , .
  
• .
  ( ).
  
• .
  , , .
• . , SwiftyStateMachine , , . .
• .
  , . , , . .
  

.



. , . , , switch case: , , — .



. . , . , , , . .



, , . .



— . : , — .





«-» .



, . .



app coordinators — , , : , . , .

, app coordinator , state machine. . , app coordinators state machine, , , , . , , , . .



, state machine , , .

state machine , if-else. , .

Apps Conf 2018, 8 9 , - .

, YouTube- . , .