एफ # 4: लेट / यूज / डू

इस पोस्ट में हम F # में बाइंडिंग को देखेंगे, विशेष रूप से हम Let / Use / Do को देखेंगे। अब आप स्वयं से पूछ सकते हैं कि क्या बाँध हैं, और चूंकि हमने अभी तक उनकी जांच नहीं की है, अब इस बारे में बात करने का समय है।

सीधे शब्दों में कहें, एक बाध्यकारी एक पहचानकर्ता को एक मूल्य या फ़ंक्शन के साथ जोड़ता है।

चलो

आप किसी मान को किसी फ़ंक्शन या फ़ंक्शन के साथ जोड़ने के लिए let कीवर्ड का उपयोग करते हैं। वास्तव में लेट का एक सूक्ष्म भिन्न उपयोग है, जहां एक मॉड्यूल में शीर्ष स्तर पर घोषित किया जाता है, और फिर दूसरा, जहां हम कुछ स्थानीय संदर्भ को परिभाषित करते हैं। यहाँ उन दोनों का एक उदाहरण दिया गया है:

module DemoModule = let someFunction = let a = 1 let b = 2 a * b 

हम पूरी तरह से योग्य नाम का उपयोग करके कुछ फंक्शन का उपयोग कर सकते हैं, जैसे कि डेमोमॉड्यूल.सोमफंक्शन, लेकिन नेस्टेड लेट (ए, बी) बाइंडिंग केवल लेट टॉप लेवल के लिए उपलब्ध हैं। आमतौर पर आप अधिक मामले देखते हैं जब हम आंतरिक मॉड्यूल के कुछ मूल्यों को घोषित करने के लिए लेट बाइंडिंग का उपयोग करते हैं, तो चलिए अपने प्रयासों को वहां केंद्रित करते हैं (हालांकि यह जानना महत्वपूर्ण है कि आप मॉड्यूल स्तर पर लेट का उपयोग कर सकते हैं)।

तो आइए कुछ और उदाहरण देखें।

 let aString ="this is a string" let aInt = 12 let aDecimal = 12.444 let aPiFunction () = Math.PI let aSquareRootFunction (x) = Math.Sqrt(x) let aFullyTypedSquareRootFunction (x :float) = Math.Sqrt(x) let a,b = "a","tuple" 

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

• पूर्णांक
• दशमलव संख्या
• इनपुट मापदंडों के बिना फ़ंक्शन
• इनपुट मापदंडों के साथ फंक्शन (जहाँ टाइप # की लॉजिकल इंट्रेंस सिस्टम सही तरीके से टाइप करेगा)
• एक फ़ंक्शन जो पूरी तरह से पैरामीटर प्रकारों को परिभाषित करता है
• टपल (इस मामले में, स्ट्रिंग * स्ट्रिंग टपल)

अन्यत्र, आप कक्षा में लेट बाइंडिंग देख सकते हैं, लेकिन हम इस श्रृंखला में अगले लेख में इस पर अधिक विस्तार से चर्चा करेंगे।

आप MSDN पर Let बाइंडिंग के बारे में अधिक पढ़ सकते हैं।

उपयोग

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

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

 use sw = new StreamWriter(@"c:\temp\fprintfFile.txt") fprintf sw "This is a string line %s\r\n" "cat" fprintf sw "This is a int line %i" 10 sw.Close() 

इस उदाहरण में, बाइंडिंग का उपयोग गारंटी देता है कि स्ट्रीमविटर विधि ऊपर दिखाए गए sw.Close () को कॉल करने के बाद अपने निपटान () विधि को कॉल करेगी।

IDisposables के साथ केवल काम करता है का उपयोग करें, और आप एक संकलन त्रुटि प्राप्त करेंगे यदि आप इसे किसी और चीज़ के साथ उपयोग करने का प्रयास करते हैं, जैसा कि नीचे दिखाया गया है:



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

 let Write = use sw = new StreamWriter(@"c:\temp\fprintfFile.txt") sw 

यदि आपको आईडीसोफ़ेक्टिव बैक पास करने की आवश्यकता है, जो कि यूज़ बाइंडिंग का हिस्सा हैं, तो आप इसके बजाय कॉलबैक का उपयोग कर सकते हैं। ऐसा कुछ काम करेगा, लेकिन अगर आप इस तरह के काम करते हैं तो मैं खुद से पूछूंगा कि क्या आपने अपना डिजाइन सही ढंग से बनाया है:

 let Write callback = use sw = new StreamWriter(@"c:\temp\fprintfFile.txt") fprintf sw "Write is writing to the StreamWriter" callback sw sw let callback sw = fprintf sw "sw is the StreamWriter" let disp = Write callback 

Do

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

यहाँ Do बाइंडिंग के उपयोग के कुछ उदाहरण दिए गए हैं।

 do printf "doing the do" //oh oh not a unit do printf "print a sum %i" 1 + 1 do 1 + 1 

अगर मैं इसके बजाय आपको ऊपर दिए गए कोड के साथ एक स्क्रीनशॉट दिखाता हूं, तो आप देखेंगे कि कंपाइलर शिकायत करेगा यदि आप गैर-यूनिट परिणाम के साथ Do का उपयोग करने का प्रयास करते हैं।



आपके पास दो विकल्प हैं:

• परिणाम को अनदेखा करने के लिए एक पाइपलाइन ऑपरेटर का उपयोग करें
• बांधने दो

मैंने उनमें से प्रत्येक का एक उदाहरण दिखाया:

 let x = 1 + 1 do printf "print a sum %i" x do (1+1 |> ignore) 

करते हैं! का प्रयोग करें! क्या!

हालाँकि मैं अभी तक उन पर चर्चा नहीं करना चाहता, कभी-कभी आप गलती से लेट को देख सकते हैं! का प्रयोग करें! करो!, और जब आप ऐसा करते हैं, तो यह एक कम्प्यूटेशनल अभिव्यक्ति कहा जाता है। आप इसे संभवतः एफ # अतुल्यकालिक वर्कफ़्लोज़ में देखेंगे, जिसे हम अंतिम लेखों में से एक में कवर करेंगे। यदि मैं पर्याप्त समझ पाता हूं, तो मैं यह भी समझाने की कोशिश कर सकता हूं कि आप अपना "कम्प्यूटेशनल एक्सप्रेशन" कैसे बना सकते हैं, हालांकि वे एक अमूर्त अवधारणा और एक जटिल विषय हैं, इसलिए अब उनके लिए समय नहीं है।