प्रोग्रामिंग भाषा स्विफ्ट। रूसी संस्करण

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

सामग्री की तालिका

स्विफ्ट में आपका स्वागत है

स्विफ्ट के बारे में

स्विफ्ट का परिचय



भाषा गाइड

मूल बातें

मूल संचालक

स्ट्रिंग और वर्ण

संग्रह के प्रकार

नियंत्रण प्रवाह

कार्य

बंद

enumerations

कक्षाएं और संरचनाएं

गुण

तरीके

सबस्क्रिप्ट

विरासत

प्रारंभ

Deinitialization

स्वचालित संदर्भ गिनती

वैकल्पिक जंजीर

कास्टिंग टाइप करें

नेस्टेड प्रकार

एक्सटेंशन

प्रोटोकॉल

जेनेरिक्स

उन्नत ऑपरेटरों



भाषा संदर्भ

भाषा संदर्भ के बारे में

लयात्मक संरचना

प्रकार

भाव

बयान

घोषणाओं

गुण

पैटर्न्स

सामान्य पैरामीटर और तर्क

व्याकरण का सारांश

ट्रेडमार्क

स्विफ्ट में आपका स्वागत है

स्विफ्ट के बारे में

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



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



उद्देश्य-सी डेवलपर्स स्विफ्ट से परिचित होंगे। यह नामित मापदंडों की पठनीयता और वस्तुनिष्ठ-सी गतिशील वस्तु मॉडल की शक्ति को जोड़ती है। यह मौजूदा कोको फ्रेमवर्क तक पहुंच प्रदान करता है और उद्देश्य-सी में लिखे गए कोड के साथ संगत है। इस सामान्य आधार पर निर्मित भाषा कई नई सुविधाएँ प्रदान करती है और एक प्रोग्रामिंग भाषा के प्रक्रियात्मक और वस्तु-उन्मुख पहलुओं को एकजुट करती है।



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



स्विफ्ट ने आधुनिक भाषाओं से सभी को शामिल किया है और इसे Apple के विशाल अनुभव के आधार पर तैयार किया गया है। हमारा संकलक प्रदर्शन का पर्याय है, समझौता किए बिना हमारी भाषा विकास के लिए अनुकूलित है। इसे इसलिए बनाया गया है ताकि आप आसानी से अपना पहला "हेल्लो, वर्ल्ड!" एप्लीकेशन विकसित कर सकें और यहाँ तक कि पूरे ऑपरेटिंग सिस्टम को भी। यह सब स्विफ्ट डेवलपर्स के लिए और स्वयं एप्पल के लिए एक महत्वपूर्ण उपकरण बनाता है।



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

स्विफ्ट का परिचय

एक लंबी परंपरा के अनुसार, एक नई भाषा में पहला कार्यक्रम “Hello, world”



शब्दों को प्रदर्शित करना चाहिए। स्विफ्ट के साथ, यह इस तरह किया जाता है:

 println("Hello, world")
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यदि आपने कभी C या Objective-C विकसित किया है, तो यह सिंटैक्स आपको परिचित होना चाहिए - स्विफ्ट में, कोड की यह लाइन एक पूर्ण प्रोग्राम है। कंसोल के लिए इनपुट / आउटपुट जैसी बुनियादी कार्यक्षमता प्रदान करने या स्ट्रिंग्स के साथ काम करने के लिए आपको अलग-अलग पुस्तकालयों को आयात करने की आवश्यकता नहीं है। वैश्विक दायरे में लिखा गया कोड कार्यक्रम का प्रवेश बिंदु है, इसलिए main



कार्य की अब आवश्यकता नहीं है। प्रत्येक पंक्ति के अंत में अर्धविराम की अनुपस्थिति पर भी ध्यान दें।



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

टिप्पणी

सामग्री की बेहतर समझ के लिए, हम Xcode में खेल का मैदान मोड का उपयोग करने की सलाह देते हैं। खेल का मैदान आपको आवेदन को संकलित करने और चलाने के बिना कोड को संपादित करने की प्रक्रिया में तुरंत परिणाम देखने की अनुमति देता है।

सरल डेटा प्रकार

वैरिएबल बनाने के लिए एक स्थिर और var



बनाने के लिए उपयोग करें। आपको निरंतर प्रकार निर्दिष्ट करने की आवश्यकता नहीं है, आप इसे केवल एक बार मान दे सकते हैं।

 var myVariable = 42 myVariable = 50 let myConstant = 42
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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



एक पूर्णांक प्रकार है।



यदि इनिशलाइज़र गायब है या पर्याप्त जानकारी प्रदान नहीं करता है, तो आप चर के बाद खुद को निर्दिष्ट कर सकते हैं, नाम और प्रकार को अलग कर सकते हैं:

 let implicitInteger = 70 let inplicitDouble = 70.0 let inplicitDouble: Double = 70
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आइए प्रयोग करते हैं

फ़्लोट का एक प्रकार बनाएं और इसे नंबर 4 से आरंभ करें।

मानों को कभी भी दूसरे प्रकार में परिवर्तित नहीं किया जाता है। यदि आपको मान को किसी अन्य प्रकार में बदलने की आवश्यकता है, तो इसे स्पष्ट रूप से करें:

 let label = "The width is " let width = 94 let widthLabel = label + String(width)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आइए प्रयोग करते हैं

अंतिम पंक्ति में स्ट्रिंग में स्पष्ट रूपांतरण को हटाने का प्रयास करें। आपको क्या त्रुटि मिलती है?

स्ट्रिंग्स में मूल्यों को शामिल करने का एक आसान तरीका है: ऐसा करने के लिए, ब्रैकेट में अभिव्यक्ति को संलग्न करें और उनके सामने एक बैकस्लैश ( \



) डालें। एक उदाहरण:

 let apples = 3 let oranges = 5 let appleSummary = "I have \(apples) apples." let fruitSummary = "I have \(apples + oranges) pieces of fruit."
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आइए प्रयोग करते हैं

\()



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

सरणियों और साहचर्य सरणियों (शब्दकोशों, शब्दकोश) के साथ काम करते समय, वर्ग कोष्ठक ( []



) का उपयोग किया जाता है:

 var shoppingList = ["catfish", "water", "tulips", "blue paint"] shoppingList[1] = "bottle of water" var occupations = [ "Malcolm": "Captain", "Kaylee": "Mechanic", ] occupations["Jayne"] = "Public Relations"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक खाली सरणी या शब्दकोश बनाने के लिए, निम्नलिखित सिंटैक्स का उपयोग करें:

 let emptyArray = String[]() let emptyDictionary = Dictionary<String, Float>()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

खाली सरणियों और शब्दकोशों को बनाने के लिए [:]



क्रमशः []



और [:]



उपयोग करें, उदाहरण के लिए, जब आप एक चर के लिए एक नया मान असाइन करते हैं या एक फ़ंक्शन के लिए एक तर्क पास करते हैं।

 shoppingList = [] // Went shopping and bought everything.
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

स्थितियां और चक्र

if



और switch



का उपयोग परिस्थितियों को बनाने के लिए किया जाता है, तो, while



और do-while



switch



का उपयोग लूप बनाने के लिए किया जाता है। उसी समय, कोष्ठकों के साथ स्थितियों और प्रारंभिक अभिव्यक्तियों का चयन करना आवश्यक नहीं है, जबकि घुंघराले ब्रेस की आवश्यकता होती है।

 let individualScores = [75, 43, 103, 87, 12] var teamScore = 0 for score in individualScores { if score > 50 { teamScore += 3 } else { teamScore += 1 } } teamScore
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

if



अंदर की स्थिति तार्किक होनी चाहिए, if score {…}



इसका विशेष रूप से मतलब यह है कि if score {…}



गलत है, if score {…}



अभिव्यक्ति गलत है, क्योंकि कोई स्पष्ट तुलना नहीं है (उदाहरण के लिए, शून्य के साथ)।



सशर्त if



को var



और वैरिएबल के साथ काम करने के लिए let



और var



के साथ संयोजन में उपयोग किया जा सकता है जो nil



हो सकते हैं। ऐसे स्थिरांक और चर को वैकल्पिक कहा जाता है (अर्थात, वे किसी भी मूल्य को ले सकते हैं या nil



)। वैकल्पिक चर या स्थिर बनाने के लिए, प्रकार निर्दिष्ट करने के बाद एक प्रश्न चिह्न ( ?



) जोड़ें।

  var optionalString: String? = "Hello" optionalString == nil var optionalName: String? = "John Appleseed" var greeting = "Hello!" if let name = optionalName { greeting = "Hello, \(name)" }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आइए प्रयोग करते हैं

optionalName



को nil



बदलें। आप स्क्रीन पर क्या देखते हैं? जब optionalName



nil



हो तो मामले को संभालने के लिए एक else



ब्लॉक जोड़ें।

यदि वैकल्पिक मूल्य nil



, तो स्थिति गलत होगी और निष्पादन के बाद ब्रेसिज़ में कोड निष्पादित नहीं किया जाएगा। अन्यथा, greeting



चर को एक नया मान सौंपा जाएगा।



एकाधिक पसंद switch



ऑपरेटर अपने भीतर कई अन्य तुलना ऑपरेटरों का समर्थन करता है और सरल तुलना तक सीमित नहीं है:

 let vegetable = "red pepper" switch vegetable { case "celery": let vegetableComment = "Add some raisins and make ants on a log." case "cucumber", "watercress": let vegetableComment = "That would make a good tea sandwich." case let x where x.hasSuffix("pepper"): let vegetableComment = "Is it a spicy \(x)?" default: let vegetableComment = "Everything tastes good in soup." }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आइए प्रयोग करते हैं

डिफ़ॉल्ट स्थिति को निकालने का प्रयास करें। आपको क्या त्रुटि मिलती है?

कोड के एक उपयुक्त ब्लॉक को निष्पादित करने के बाद, प्रोग्राम निम्नलिखित शर्तों की जांच किए बिना switch



को छोड़ देता है। इस प्रकार, आपको प्रत्येक case



ब्लॉक के अंत में मैन्युअल रूप से break



स्टेटमेंट जोड़ने की आवश्यकता नहीं है।



एक सहयोगी सरणी के तत्वों पर पुनरावृति करने के लिए, प्रत्येक कुंजी-मान जोड़ी के लिए नाम जोड़ी के साथ for-in



साथ ऑपरेटर का उपयोग करें।

 let interestingNumbers = [ "Prime": [2, 3, 5, 7, 11, 13], "Fibonacci": [1, 1, 2, 3, 5, 8], "Square": [1, 4, 9, 16, 25], ] var largest = 0 for (kind, numbers) in interestingNumbers { for number in numbers { if number > largest { largest = number } } } largest
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आइए प्रयोग करते हैं

एक और वैरिएबल जोड़ें जो आपको यह पता लगाने की अनुमति देता है कि अधिकतम तीन प्रकार में से कौन सा नंबर किससे संबंधित है

while



स्टेटमेंट आपको इसके अंदर कोड के एक ब्लॉक को निष्पादित करने की अनुमति देता है जब तक कि स्थिति झूठी न हो जाए। स्थिति को ब्लॉक के बाद भी संकेत दिया जा सकता है, जो इस मामले में कम से कम एक बार निष्पादित किया जाएगा।

 var n = 2 while n < 100 { n = n * 2 } n var m = 2 do { m = m * 2 } while m < 100 m
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

दो बिंदुओं ( ..



) का उपयोग करते हुए या एक इनिशलाइज़र, कंडीशन और इंक्रीमेंट का उपयोग करके संख्याओं के अनुक्रम में पुनरावृति के for



स्टेटमेंट के for



उपयोग किया जा सकता है। देखिए, ये दोनों चक्र एक ही काम करते हैं:

 var firstForLoop = 0 for i in 0..3 { firstForLoop += i } firstForLoop var secondForLoop = 0 for var i = 0; i < 3; ++i { secondForLoop += 1 } secondForLoop
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

लूप बनाते समय, दो बिंदुओं का उपयोग करें ( ..



) यदि आप रेंज में एक बड़ा मान शामिल नहीं करना चाहते हैं, और तीन बिंदुओं ( …



) में एक छोटा और बड़ा मान दोनों शामिल हैं।

कार्य और बंद।

फ़ंक्शन घोषित करने के लिए func



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



साथ।

 func greet(name: String, day: String) -> String { return "Hello \(name), today is \(day)." } greet("Bob", "Tuesday")
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आइए प्रयोग करते हैं

दिन पैरामीटर निकालें। इसके बजाय, दोपहर के भोजन के लिए परोसे जाने वाले भोजन के नाम को इंगित करने वाला एक चर जोड़ें।

यदि कोई फ़ंक्शन कई मान लौटाता है, तो आपको एक टपल का उपयोग करना चाहिए:

 func getGasPrices() -> (Double, Double, Double) { return (3.59, 3.69, 3.79) } getGasPrices()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

फ़ंक्शंस में अपरिभाषित संख्याएँ भी हो सकती हैं:

 func sumOf(numbers: Int...) -> Int { var sum = 0 for number in numbers { sum += number } return sum } sumOf() sumOf(42, 597, 12)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आइए प्रयोग करते हैं

एक फ़ंक्शन लिखें जो आपको अपने तर्कों की एक मनमानी संख्या के अंकगणित माध्य को खोजने की अनुमति देता है।

कार्यों को एक साथ मिलकर किया जा सकता है। एक नेस्टेड फ़ंक्शन बाहरी फ़ंक्शन में घोषित चर तक पहुंच सकता है। जटिल या बड़े फ़ंक्शन कोड को व्यवस्थित करने के लिए नेस्टेड फ़ंक्शन का उपयोग करें।

 func returnFifteen() -> Int { var y = 10 func add() { y += 5 } add() return y } returnFifteen()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

फ़ंक्शंस प्रथम श्रेणी के प्रकार के ऑब्जेक्ट हैं, दूसरे शब्दों में, एक फ़ंक्शन इसके परिणाम के रूप में किसी अन्य फ़ंक्शन को वापस कर सकता है।

 func makeIncrementer() -> (Int -> Int) { func addOne(number: Int) -> Int { return 1 + number } return addOne } var increment = makeIncrementer() increment(7)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक फ़ंक्शन दूसरे फ़ंक्शन को भी उसके तर्क के रूप में ले सकता है।

 func hasAnyMatches(list: Int[], condition: Int -> Bool) -> Bool { for item in list { if condition(item) { return true } } return false } func lessThanTen(number: Int) -> Bool { return number < 10 } var numbers = [20, 19, 7, 12] hasAnyMatches(numbers, lessThanTen)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

कार्य बंद होने का एक विशेष मामला है। आप इसके नाम को निर्दिष्ट किए बिना एक करीबी बना सकते हैं और करीबी ब्रेसिज़ ( {}



) के साथ बंद शरीर के आसपास हो सकते हैं। क्लोजर के शरीर से तर्क और वापसी प्रकार को अलग करने के लिए, ऑपरेटर in



उपयोग करें।

 numbers.map({ (number: Int) -> Int in let result = 3 * number return result })
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आइए प्रयोग करते हैं

क्लोजर को फिर से लिखें ताकि यह सभी अतिरिक्त संख्याओं के लिए शून्य लौटाए।

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

 numbers.map({ number in 3 * number })
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

 sort([1, 5, 3, 12, 2]) { $0 > $1 }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

वस्तुओं और वर्गों

एक वर्ग बनाने के लिए, आरक्षित शब्द class



उपयोग करें। कक्षा सदस्यों को उसी तरह से घोषित किया जाता है जैसे नियमित रूप से स्थिरांक और चर। इसके अलावा, कक्षा के तरीकों को सामान्य कार्यों के रूप में घोषित किया जाता है।

 class Shape { var numberOfSides = 0 func simpleDescription() -> String { return "A shape with \(numberOfSides) sides." } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आइए प्रयोग करते हैं

एक वर्ग सदस्य स्थिरांक और एक वर्ग विधि जोड़ें जो इसे अपने तर्क के रूप में लेता है।

किसी वर्ग का उदाहरण (ऑब्जेक्ट) बनाने के लिए, कक्षा के नाम के बाद कोष्ठक जोड़ें। विधियों और वर्ग के सदस्यों तक पहुँच एक बिंदु के माध्यम से है।

 var shape = Shape() shape.numberOfSides = 7 var shapeDescription = shape.simpleDescription()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस उदाहरण में, हमने एक महत्वपूर्ण विवरण याद किया - क्लास कंस्ट्रक्टर, init



विधि।

 class NamedShape { var numberOfSides: Int = 0 var name: String init(name: String) { self.name = name } func simpleDescription() -> String { return "A shape with \(numberOfSides) sides." } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ध्यान दें कि नाम वर्ग का सदस्य, self



का उपयोग करते हुए self



तर्क से name



निर्माणकर्ता से अलग हो जाता है। निर्माणकर्ता को सामान्य तरीके से तर्क पारित किए जाते हैं, जैसे किसी अन्य वर्ग विधि में। ध्यान दें कि कक्षा के प्रत्येक सदस्य को प्रारंभिक रूप से घोषित किया जाना चाहिए - या तो घोषणा के दौरान (जैसे कि numberOfSides



) या कंस्ट्रक्टर ( name



रूप में)।



वर्ग विध्वंसक deinit



विधि है, जिसे यदि आवश्यक हो तो फिर से लिखा जा सकता है।



एक मौजूदा कक्षा से एक वर्ग प्राप्त करने के लिए, बच्चे वर्ग के नाम को निर्दिष्ट करने के बाद, एक बृहदान्त्र डालें और माता-पिता के नाम का संकेत दें। स्विफ्ट में, किसी भी मानक वर्ग की अनिवार्य विरासत पर कोई प्रतिबंध नहीं है।



बाल वर्ग override



विधियों को कीवर्ड override



के साथ चिह्नित किया जाना चाहिए - ओवरराइड के बिना ओवरराइडिंग विधियों के परिणामस्वरूप त्रुटि होगी। कंपाइलर override



लेबल वाले तरीकों का भी पता लगाता है, लेकिन अपने मूल वर्ग के किसी भी तरीके को ओवरराइड नहीं करता है।

 class Square: NamedShape { var sideLength: Double init(sideLength: Double, name: String) { self.sideLength = sideLength super.init(name: name) numberOfSides = 4 } func area() -> Double { return sideLength * sideLength } override func simpleDescription() -> String { return "A square with sides of length \(sideLength)." } } let test = Square(sideLength: 5.2, name: "my test square") test.area() test.simpleDescription()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आइए प्रयोग करते हैं

Circle



वर्ग बनाएँ और इसे NamedShape



वर्ग से विरासत में NamedShape



। Circle



वर्ग के लिए निर्माता दो तर्क - त्रिज्या और नाम लेता है। area



ओवरराइड करें और इस वर्ग के तरीकों का describe



करें।

कक्षा के सदस्यों के पास अपना स्वयं का getter



और setter



भी हो सकता है।

 class EquilateralTriangle: NamedShape { var sideLength: Double = 0.0 init(sideLength: Double, name: String) { self.sideLength = sideLength super.init(name: name) numberOfSides = 3 } var perimeter: Double { get { return 3.0 * sideLength } set { sideLength = newValue / 3.0 } } override func simpleDescription() -> String { return "An equilateral triagle with sides of length \(sideLength)." } } var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle") triangle.perimeter triangle.perimeter = 9.9 triangle.sideLength
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

perimeter



के setter



चर में perimeter



नए असाइन किए गए मान को स्पष्ट रूप से newValue



कहा जाता है। आप इस चर का नाम set



तुरंत बाद कोष्ठक में निर्दिष्ट करके बदल सकते हैं।



EquilateralTriangle



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

1. बाल वर्ग के सदस्यों का आरंभीकरण;
2. मूल वर्ग के निर्माता को बुला रहा है;
3. माता-पिता वर्ग के सदस्यों के मूल्यों को बदलना।

यदि आपको किसी वैरिएबल को नया मान देने से पहले या बाद में कुछ कोड निष्पादित करने की आवश्यकता है, तो आप अपनी आवश्यकता के अनुसार willSet



और didSet



विधियों willSet



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

 class TriangleAndSquare { var triangle: EquilateralTriangle { willSet { square.sideLength = newValue.sideLength } } var square: Square { willSet { triangle.sideLength = newValue.sideLength } } init(size: Double, name: String) { square = Square(sideLength: size, name: name) triangle = EquilateralTriangle(sideLength: size, name: name) } } var triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape") triangleAndSquare.square.sideLength triangleAndSquare.triangle.sideLength triangleAndSquare.square = Square(sideLength: 50, name: "larger square") triangleAndSquare.triangle.sideLength
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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



) का उपयोग करना होगा।

 class Counter { var count: Int = 0 func incrementBy(amount: Int, numberOfTimes times: Int) { count += amount * times } } var counter = Counter() counter.incrementBy(2, numberOfTimes: 7)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

वैकल्पिक मानों के साथ काम करते समय, तरीकों, वर्ग के सदस्यों आदि के सामने एक प्रश्न चिह्न ( ?



) जोड़ें। यदि प्रश्न चिह्न के पहले मान nil



, तो जो कुछ भी है वह ( ?



) अनदेखा है और संपूर्ण अभिव्यक्ति का मूल्य nil



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

 let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square") let sideLength = optionalSquare?.sideLength
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

गणना और संरचनाएं

Enumerations बनाने के लिए enum



keyword का उपयोग किया जाता है। ध्यान दें कि स्थानांतरण में विधियाँ भी शामिल हो सकती हैं।

 enum Rank: Int { case Ace = 1 case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten case Jack, Queen, King func simpleDescription() -> String { switch self { case .Ace: return "ace" case .Jack: return "jack" case .Queen: return "queen" case .King: return "king" default: return String(self.toRaw()) } } } let ace = Rank.Ace let aceRawValue = ace.toRaw()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आइए प्रयोग करते हैं

एक फ़ंक्शन लिखें जो उनके मानों द्वारा 2 Rank



गणनाओं की तुलना करता है।

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



मूल मान प्रकार को एन्यूमरेशन प्रकार में परिवर्तित करने के लिए, toRaw



और fromRaw



उपयोग करें।

 if let convertedRank = Rank.fromRaw(3) { let threeDescription = convertedRank.simpleDescription() }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ध्यान दें कि गणना तत्वों के मूल्य वास्तविक हैं, न कि उनके मूल मूल्यों का केवल एक और रिकॉर्ड। सामान्यतया, आप उनके प्रारंभिक मूल्यों का संकेत नहीं दे सकते हैं।

 enum Suit { case Spades, Hearts, Diamonds, Clubs func simpleDescription() -> String { switch self { case .Spades: return "spades" case .Hearts: return "hearts" case .Diamonds: return "diamonds" case .Clubs: return "clubs" } } } let hearts = Suit.Hearts let heartsDescription = hearts.simpleDescription()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आइए प्रयोग करते हैं

एक Color



विधि जोड़ें जो Spades



और Clubs



लिए स्ट्रिंग “black”



लौटाता है और Hearts



और Diamonds



लिए “red”



।

ध्यान दें कि Suit



लिस्टिंग के Hearts



सदस्य के लिए उपयोग कैसे किया जाता है। जब hearts



स्थिर रखने के लिए एक मूल्य प्रदान किया जाता है, तो पूरा नाम Suit.Hearts



, क्योंकि हम इस स्थिरांक के प्रकार को स्पष्ट रूप से निर्दिष्ट नहीं करते हैं। और switch



हम संक्षिप्त रूप का उपयोग करते हैं। .Hearts



, चूंकि self



मूल्य का प्रकार एक प्राथमिकता ज्ञात है। यदि चर का प्रकार स्पष्ट रूप से निर्दिष्ट किया गया है, तो आप हर जगह संक्षिप्त रूप का उपयोग कर सकते हैं।



struct



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

 struct Card { var rank: Rank var suit: Suit func simpleDescription() -> String { return "The \(rank.simpleDescription()) of \(suit.simpleDescription())" } } let threeOfSpades = Card(rank: .Three, suit: .Spades) let threeOfSpadesDescription = threeOfSpades.simpleDescription()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आइए प्रयोग करते हैं

कार्ड संरचना में एक विधि जोड़ें जो कार्ड का एक पूर्ण डेक बनाता है।

एक गणन सदस्य के उदाहरण के अपने मूल्य हो सकते हैं और वे भिन्न हो सकते हैं। गणना मूल्यों (उदाहरण में निरंतर success



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



सर्वर से सूर्योदय और सूर्यास्त के समय को प्राप्त करने के उदाहरण पर विचार करें। सर्वर प्रासंगिक जानकारी या त्रुटि संदेश के साथ प्रतिक्रिया करता है।

 enum ServerResponse { case Result(String, String) case Error(String) } let success = ServerResponse.Result("6:00 am", "8:09 pm") let failure = ServerResponse.Error("Out of cheese.") switch success { case let .Result(sunrise, sunset): let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)." case let .Error(error): let serverResponse = "Failure... \(error)" }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आइए प्रयोग करते हैं

तीसरे विकल्प को switch



करने के switch



कई विकल्प चुनें

ध्यान दें कि कैसे सूर्योदय और सूर्यास्त का समय ServerResponse



ऑब्जेक्ट से खींचा जाता है।

प्रोटोकॉल और एक्सटेंशन।

प्रोटोकॉल घोषित करने के लिए, प्रोटोकॉल कीवर्ड का उपयोग करें।

 protocol ExampleProtocol { var simpleDescription: String { get } mutating func adjust() }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

प्रोटोकॉल कक्षाओं, गणना, और संरचनाओं द्वारा समर्थित हो सकते हैं।

 class SimpleClass: ExampleProtocol { var simpleDescription: String = "A very simple class." var anotherProperty: Int = 69105 func adjust() { simpleDescription += " Now 100% adjusted." } } var a = SimpleClass() a.adjust() let aDescription = a.simpleDescription struct SimpleStructure: ExampleProtocol { var simpleDescription: String = "A simple structure" mutating func adjust() { simpleDescription += " (adjusted)" } } var b = SimpleStructure() b.adjust() let bDescription = b.simpleDescription
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आइए प्रयोग करते हैं

एक गणना बनाएं जो इस प्रोटोकॉल को लागू करेगा।

SimpleStructure



संरचना SimpleStructure



में SimpleStructure



कीवर्ड पर ध्यान दें, जो कंपाइलर को सूचित करता है कि संबंधित विधि परिवर्तन के लिए संरचना के अधीन है। इसके विपरीत, SimpleClass



क्लास के तरीकों को SimpleClass



के रूप में चिह्नित SimpleClass



नहीं है, क्योंकि क्लास के तरीके हमेशा इसे बिना बदले बदल सकते हैं।



किसी मौजूदा प्रकार में नए तरीके या वर्ग के सदस्यों को जोड़ने के लिए, आपको - एक्सटेंशन का उपयोग करना चाहिए extensions



। आप किसी मौजूदा प्रकार के प्रोटोकॉल को लागू करने के लिए एक्सटेंशन का उपयोग कर सकते हैं, भले ही वह किसी लाइब्रेरी या फ्रेमवर्क से आयात किया गया हो।

 extension Int: ExampleProtocol { var simpleDescription: String { return "The number \(self)" } mutating func adjust() { self += 42 } } 7.simpleDescription
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

चलो प्रयोग करते हैं। एक सदस्य चर के साथ एक

प्रकार का विस्तार बनाएँ ।Double



absoluteValue

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

 let protocolValue: ExampleProtocol = a protocolValue.simpleDescription // protocolValue.anotherProperty // Uncomment to see the error
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस तथ्य के बावजूद कि कार्यक्रम के निष्पादन के दौरान चर protocolValue



का एक प्रकार है SimpleClass



, संकलक अपने प्रकार को मानता है ExampleProtocol



। इसका मतलब है कि आप गलती से तरीकों या किसी वर्ग के सदस्यों तक नहीं पहुंच सकते हैं जो प्रोटोकॉल के बाहर कार्यान्वित किए जाते हैं ExampleProtocol



।

सामान्य प्रकार

एक सामान्य प्रकार बनाने के लिए, कोण कोष्ठक ( <>



) में नाम संलग्न करें ।

 func repeat<ItemType>(item: ItemType, times: Int) -> ItemType[] { var result = ItemType[]() for i in 0..times { result += item } return result } repeat("knock", 4)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

सामान्य कार्य, कक्षाएं, गणना, और संरचनाएं बनाएं।

 // Reimplement the Swift standard library's optional type enum OptionalValue<T> { case None case Some(T) } var possibleInteger: OptionalValue<Int> = .None possibleInteger = .Some(100)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यदि आप एक प्रकार के लिए निर्दिष्ट विशिष्ट आवश्यकताओं को निर्दिष्ट करना चाहते हैं, जैसे कि, उदाहरण के लिए, एक प्रोटोकॉल कार्यान्वयन या एक विशिष्ट वर्ग से विरासत में मिली आवश्यकता, उपयोग where



।

 func anyCommonElements <T, U where T: Sequence, U: Sequence, T.GeneratorType.Element: Equatable, T.GeneratorType.Element == U.GeneratorType.Element> (lhs: T, rhs: U) -> Bool { for lhsItem in lhs { for rhsItem in rhs { if lhsItem == rhsItem { return true } } } return false } anyCommonElements([1, 2, 3], [3])
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आइए प्रयोग

करें। फ़ंक्शन को संशोधित करें anyCommonElements



ताकि यह सामान्य तत्वों की एक सरणी लौटाए।

साधारण मामलों में, आप where



बृहदान्त्र के बाद प्रोटोकॉल या वर्ग का नाम छोड़ सकते हैं और लिख सकते हैं । एक अभिव्यक्ति एक अभिव्यक्ति के <T: Equatable>



बराबर है <T where T: Equatable>



।

10 मिनट में एक iOS ऐप में सब्सक्रिप्शन लागू करना चाहते हैं? Apphud को एकीकृत करें और:

- केवल एक विधि का उपयोग करके खरीदारी करें;

- स्वचालित रूप से प्रत्येक उपयोगकर्ता की सदस्यता की स्थिति को ट्रैक करता है;

- आसानी से सदस्यता प्रस्तावों को एकीकृत;

- उपयोगकर्ता की स्थानीय मुद्रा को ध्यान में रखते हुए सदस्यता घटनाओं, मिक्सपैनेल, स्लैक और टेलीग्राम को भेजें;

- अनुप्रयोगों में मंथन दर को कम करें और बिना सदस्यता वाले उपयोगकर्ताओं को लौटाएं।