एफ # 7: रिकॉर्ड

इसलिए, हम अधिक एफ # प्रकार की अपनी यात्रा जारी रखते हैं। इस बार हम रिकॉर्ड्स के प्रकारों पर ध्यान देंगे।

मैं एक पोस्ट कैसे बनाऊं

जब आप एक नया F # प्रविष्टि बनाते हैं, तो यह आपको C # में अनाम वस्तुओं की याद दिला सकता है। यह आप उन्हें कैसे बनाते हैं। मुझे लगता है कि वे C # में अनाम वस्तुओं के समान हैं, इसलिए यदि आपने C # का उपयोग किया है, तो F # प्रविष्टियां जटिल नहीं होनी चाहिए।

यह सब रिकॉर्डिंग के लिए एक नया प्रकार बनाने के साथ शुरू होता है। प्रकार की परिभाषा गुणों के नाम को सूचीबद्ध करती है, साथ ही साथ गुणों का प्रकार, जैसा कि नीचे देखा जा सकता है।

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

type Person = { Age : int; Sex: string; Name:string; } .... .... .... .... let sam = { Age = 12; Sex="Male"; Name ="Sam" } printfn "let sam = { Age = 12; Sex=\"Male\"; Name=\"Sam\" }" printfn "Person with Age is %i and Sex is %s and Name is %s" sam.Age sam.Sex sam.Name 

मैं रिकॉर्ड को कैसे बदल / क्लोन कर सकता हूं

आप प्रविष्टि को क्लोन और संशोधित कर सकते हैं, जो आमतौर पर निम्नानुसार किया जाता है:

 let sam = { Age = 12; Sex="Male"; Name ="Sam" } let tom = { sam with Name="Tom" } printfn "let tom = { sam with Name=\"Tom\" }" printfn "Person with Age is %i and Sex is %s and Name is %s" tom.Age tom.Sex tom.Name 

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

यहां एक उदाहरण है, ध्यान दें कि मैंने एक नया प्रकार कैसे बनाया जिसमें एक उत्परिवर्तनीय गुण है जिसे MutableName कहा जाता है। एक परिवर्तनशील क्षेत्र को परिभाषित करके, मुझे एक रिकॉर्ड के म्यूटेबलनाम संपत्ति के मूल्य को अपडेट करने की अनुमति है, जिसे आप "<-" ऑपरेटर का उपयोग करके कर सकते हैं। जो आपको केवल एक नया मान प्रदान करने की अनुमति देता है।

 type MutableNamePerson = { Age : int; Sex: string; mutable MutableName:string; } .... .... .... .... //create let sam = { Age = 12; Sex="Male"; MutableName ="Sam" } printfn "let sam = { Age = 12; Sex=\"Male\"; Name=\"Sam\" }" printfn "Person with Age is %i and Sex is %s and Name is %s" sam.Age sam.Sex sam.MutableName //update sam.MutableName <- "Name changed" printfn "sam.MutableName <- \"Name changed\"" printfn "Person with Age is %i and Sex is %s and Name is %s" sam.Age sam.Sex sam.MutableName 

रिकॉर्ड्स की तुलना

रिकॉर्ड प्रकार केवल समान हैं यदि सभी गुणों को समान माना जाता है। यहाँ एक उदाहरण है:

 type Person = { Age : int; Sex: string; Name:string; } .... .... .... .... let someFunction p1 p2 = printfn "p1=%A, and p2=%A, are they equal %b" p1 p2 (p1=p2) let sam = { Age = 12; Sex = "Male"; Name = "Sam" } let john = { Age = 12; Sex = "Male"; Name = "John" } let april = { Age = 35; Sex = "Female"; Name = "April" } let sam2 = { Age = 12; Sex = "Male"; Name = "Sam" } do someFunction sam john do someFunction sam april do someFunction sam sam2 

रिकॉर्ड तुलना पैटर्न

बेशक, आप पैटर्न मिलान (अगले दिन चर्चा) का उपयोग कर सकते हैं, जो रिकॉर्ड प्रकारों से मेल करने के लिए मुख्य एफ # विधि है। यहाँ एक उदाहरण है:

 type Person = { Age : int; Sex: string; Name:string; } ..... ..... ..... ..... let someFunction (somePerson :Person) = match somePerson with | { Name="Sam" } -> printfn "Sam is in the house" | _ -> printfn "you aint Sam, get outta here clown" let sam = { Age = 12; Sex="Male"; Name ="Sam" } let john = { Age = 12; Sex="Male"; Name ="John" } do someFunction sam do someFunction john 

तरीके और गुण

प्रविष्टियों में अतिरिक्त सदस्यों को जोड़ना भी संभव है। यहां एक उदाहरण है जहां हम "विवरण" संपत्ति जोड़ते हैं, जिससे हमें एक संपत्ति का उपयोग करके रिकॉर्ड के बारे में पूरी जानकारी प्राप्त करने की अनुमति मिलती है (जितना हम ToString () विधि को ओवरराइड करके प्राप्त कर सकते हैं, लेकिन बाद में OOP विधियों पर अधिक)

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



यह आसानी से रिकॉर्ड संपत्ति परिभाषाओं को एक नई पंक्ति में रखकर हल करना आसान है, और यह सुनिश्चित करना कि तत्व भी एक नई लाइन पर शुरू होता है, और इस इंडेंटेशन (स्थान) का निरीक्षण करें, क्योंकि यह सब एफ # में महत्वपूर्ण है:

 type Person = { Age : int; Sex: string; Name:string; } member this.Details = this.Age.ToString() + " " + this.Sex.ToString() + " " + this.Name .... .... .... .... let sam = { Age = 12; Sex = "Male"; Name = "Sam" } printfn "sam Details=%s" sam.Details